commit lotus dist.

.gitignore

@@ -0,0 +1 @@
+*.map

Dockerfile

@@ -24,6 +24,21 @@ WORKDIR /app
 # Copy the entire project including node_modules
 COPY . .
 
+# Remove .env.local if exists
+RUN rm -f .env.local
+
+# Set all environment variables
+ENV PORT=7860
+ENV HOST=0.0.0.0
+ENV LILYPOND_DATADIR=/app/node-addon-lilypond/output/share/lilypond/current/
+ENV GUILE_LOAD_PATH=/app/node-addon-lilypond/output/share/guile/1.8
+ENV LD_LIBRARY_PATH=/app/node-addon-lilypond/output
+ENV LILYPOND_ADDON=/app/node-addon-lilypond/output/lilypond.node
+
+ENV TEMP_DIR=./temp/
+ENV LILYPOND_DIR=""
+ENV MIDI_FILE_EXTEND=midi
+
 # Expose port
 EXPOSE 7860
 

backend/advancedEngraver.ts

@@ -0,0 +1,169 @@
+
+import {Writable} from "stream";
+import {MusicNotation} from "@k-l-lambda/music-widgets";
+import {DOMParser} from "xmldom";
+
+import {LilyDocument, docLocationSet} from "../inc/lilyParser";
+import {engraveSvg} from "./lilyCommands";
+import {SingleLock} from "../inc/mutex";
+import * as staffSvg from "../inc/staffSvg";
+import * as LilyNotation from "../inc/lilyNotation";
+import LogRecorder from "../inc/logRecorder";
+
+
+
+type StaffArguments = {attributes: staffSvg.StaffAttributes, tieLocations?: Set<string>, briefChordLocations?: Set<string>, lyricLocations?: Set<string>};
+
+
+interface EngraverOptions {
+	streamSeparator: string;
+
+	includeFolders: string[];
+	withMIDI: boolean;
+	withNotation: boolean;
+	withLilyDoc: boolean;
+	withLilyNotation: boolean;
+	logger: LogRecorder;
+
+	lilyNotation: LilyNotation.Notation;
+	staffArgs: StaffArguments;
+};
+
+
+interface GrammarParser {
+	parse (source: string): any;
+};
+
+
+const STREAM_SEPARATOR = "\n\n\n\n";
+
+
+const advancedEngrave = async (source: string, lilyParser: GrammarParser, output: Writable, options: Partial<EngraverOptions> = {}) => {
+	const {streamSeparator = STREAM_SEPARATOR} = options;
+
+	const outputJSON = data => setImmediate(() => {
+		output.write(JSON.stringify(data));
+		output.write(streamSeparator);
+	});
+
+	const t0 = Date.now();
+
+	const notatioinGen = new SingleLock<LilyNotation.Notation>(true);
+	const argsGen = new SingleLock<StaffArguments>(true);
+
+	const hashKeys = new Set<string>();
+
+	const engraving = await engraveSvg(source, {
+		includeFolders: options.includeFolders,
+
+		// do some work during lilypond process running to save time
+		onProcStart: () => {
+			//console.log("tp.0:", Date.now() - t0);
+			if (options.staffArgs)
+				argsGen.release(options.staffArgs);
+
+			if (!options.withLilyNotation && !options.withLilyDoc && options.staffArgs)
+				return;
+
+			const lilyDocument = new LilyDocument(lilyParser.parse(source));
+
+			if (!options.lilyNotation) {
+				const interpreter = lilyDocument.interpret();
+				options.lilyNotation = interpreter.getNotation();
+
+				notatioinGen.release(options.lilyNotation);
+				//console.log("tp.1:", Date.now() - t0);
+			}
+
+			if (options.withLilyDoc)
+				outputJSON({lilyDocument: lilyDocument.root});
+
+			if (!options.staffArgs) {
+				const attributes = lilyDocument.globalAttributes({readonly: true}) as staffSvg.StaffAttributes;
+
+				const tieLocations = docLocationSet(lilyDocument.getTiedNoteLocations2());
+				const briefChordLocations = docLocationSet(lilyDocument.getBriefChordLocations());
+				const lyricLocations = docLocationSet(lilyDocument.getLyricLocations());
+
+				//console.log("tp.2:", Date.now() - t0);
+
+				options.staffArgs = {attributes, tieLocations, briefChordLocations, lyricLocations};
+				argsGen.release(options.staffArgs);
+				//console.log("tp.3:", Date.now() - t0);
+			}
+		},
+		onMidiRead: async midi => {
+			//console.log("tm.0:", Date.now() - t0);
+			if (options.withMIDI)
+				outputJSON({midi});
+
+			if (options.withNotation && midi) {
+				const midiNotation = MusicNotation.Notation.parseMidi(midi);
+				outputJSON({midiNotation});
+			}
+
+			if (options.withLilyNotation && midi) {
+				const lilyNotation = options.lilyNotation || await notatioinGen.wait();
+				//console.log("tm.2:", Date.now() - t0);
+				await LilyNotation.matchWithExactMIDI(lilyNotation, midi);
+				//console.log("tm.3:", Date.now() - t0);
+
+				outputJSON({lilyNotation});
+			}
+
+			//console.log("tm.4:", Date.now() - t0);
+		},
+		onSvgRead: async (index, svg) => {
+			//console.log("ts.0:", index, Date.now() - t0);
+			const args = options.staffArgs || await argsGen.wait();
+			//console.log("ts.1:", index, Date.now() - t0);
+			const page = staffSvg.parseSvgPage(svg, source, {DOMParser, logger: options.logger, ...args});
+
+			// select incremental keys to send
+			const hashTable = {};
+			Object.entries(page.hashTable).forEach(([key, elem]) => {
+				if (!hashKeys.has(key))
+					hashTable[key] = elem;
+			});
+
+			// rectify page data by lilyNotation
+			const lilyNotation = options.lilyNotation || await notatioinGen.wait();
+			//console.log("ts.2:", index, Date.now() - t0);
+			if (lilyNotation) {
+				const sheetDocument = new staffSvg.SheetDocument({pages: [page.structure]}, {initialize: true});
+
+				sheetDocument.alignTokensWithNotation(options.lilyNotation, {partial: true});
+				sheetDocument.updateMatchedTokens(options.lilyNotation.idSet);
+			}
+
+			outputJSON({
+				page: index,
+				structure: page.structure,
+				hashTable,
+			});
+
+			Object.keys(hashTable).forEach(key => hashKeys.add(key));
+
+			//console.log("ts.3:", index, Date.now() - t0);
+		},
+	});
+
+	const tn = Date.now();
+	//console.log("tn:", tn - t0);
+
+	options.logger.append("advancedEngraver.profile.engraving", {cost: tn - t0});
+
+	await new Promise(resolve => setImmediate(resolve));
+
+	output.write(JSON.stringify({
+		logs: engraving.logs,
+		logger: options.logger,
+		errorLevel: engraving.errorLevel,
+	}));
+};
+
+
+
+export {
+	advancedEngrave,
+};

backend/canvas.ts

@@ -0,0 +1,26 @@
+
+//import {loadImage, createCanvas} from "canvas";
+import {PNGStream} from "canvas";
+
+const {loadImage, createCanvas}: any = !process.env.MOBILE_MODE ? require("canvas") : {};
+
+
+
+const svgToPng = async (sourceURL: string|Buffer): Promise<PNGStream> => {
+	if (process.env.MOBILE_MODE)
+		return;
+
+	const image = await loadImage(sourceURL);
+
+	const canvas = createCanvas(image.width, image.height);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(image, 0, 0, image.width, image.height);
+
+	return canvas.createPNGStream();
+};
+
+
+
+export {
+	svgToPng,
+};

backend/constants.ts

@@ -0,0 +1,13 @@
+
+import path from "path";
+
+
+
+// @ts-ignore
+const LY_INCLUDE_FOLDERS = ["../ly"].map(folder => path.resolve(process.env.TEMP_DIR, folder));
+
+
+
+export {
+	LY_INCLUDE_FOLDERS,
+};

backend/dirServer.ts

@@ -0,0 +1,41 @@
+
+import path from "path";
+import serveHandler from "serve-handler";
+
+
+
+const createHandler = (publicDir: string, apiPath: string) => (req, res) => {
+	req.url = "/" + path.relative(`${apiPath}/`, req.baseUrl);
+
+	// modify link URL origin
+	const responseProxy = new Proxy(res, {
+		get (res, prop) {
+			//console.log("proxy.get:", prop);
+			switch (prop) {
+			case "end":
+				return (content) => {
+					//console.log("end with:", content);
+					const html = content && content.replace(/href="/g, `href="${apiPath}`);
+
+					res.end(html);
+				};
+			}
+
+			if (typeof res[prop] === "function")
+				return res[prop].bind(res);
+
+			return res[prop];
+		},
+	});
+
+	serveHandler(req, responseProxy, {
+		public: publicDir,
+		//symlinks: true,
+	});
+};
+
+
+
+export {
+	createHandler,
+};

backend/index.ts

@@ -0,0 +1,155 @@
+
+import formidable from "formidable";
+import {DOMParser} from "xmldom";
+import {MIDI} from "@k-l-lambda/music-widgets";
+
+import * as lilyCommands from "./lilyCommands";
+import * as staffSvg from "../inc/staffSvg";
+import loadLilyParser from "./loadLilyParserNode";
+import {LilyDocument} from "../inc/lilyParser";
+import LogRecorder from "../inc/logRecorder";
+import * as ScoreMaker from "./scoreMaker";
+import * as constants from "./constants";
+import {advancedEngrave} from "./advancedEngraver";
+
+
+
+const formidableHandle = (name, req, res, handle) =>
+	new formidable.IncomingForm().parse(req, async (err, fields, files) => {
+		try {
+			if (err)
+				throw err;
+
+			const result = await handle(fields, files);
+
+			const resultObj = (typeof result === "string" || result instanceof Buffer) ? {body: result} : result;
+
+			res.writeHead(resultObj.body ? 200 : 404, resultObj.header);
+			res.write(resultObj.body);
+			res.end();
+		}
+		catch (error) {
+			console.error(`${name} error:`, error);
+
+			res.writeHead(500);
+			res.write(error.toString());
+			res.end();
+		}
+	});
+
+
+const service = {
+	"/musicxml2ly": {
+		post: (req, res) => formidableHandle("musicxml2ly", req, res,
+			({xml, options}) => lilyCommands.xml2ly(xml, options && JSON.parse(options))),
+	},
+
+
+	"/midi2ly": {
+		post: (req, res) => formidableHandle("midi2ly", req, res,
+			({options}, {midi}) => lilyCommands.midi2ly(midi, options && JSON.parse(options))),
+	},
+
+
+	"/engrave": {
+		post: (req, res) => formidableHandle("engrave", req, res,
+			async ({source, tokenize = false, log = false}) => {
+				const result = await lilyCommands.engraveSvg(source, {includeFolders: constants.LY_INCLUDE_FOLDERS});
+				if (!tokenize)
+					return JSON.stringify(result);
+
+				const lilyParser = await loadLilyParser();
+				const lilyDocument = new LilyDocument(lilyParser.parse(source));
+				//const attributes = lilyDocument.globalAttributes({readonly: true});
+				//console.log("attributes:", attributes);
+
+				lilyDocument.interpret();
+
+				const logger = new LogRecorder({enabled: log});
+
+				const {doc, hashTable} = staffSvg.createSheetDocumentFromSvgs(result.svgs, source, lilyDocument, {logger, DOMParser});
+
+				return JSON.stringify({
+					...result,
+					doc,
+					hashTable,
+					logger,
+				});
+			}),
+	},
+
+
+	"/engraveScm": {
+		post: (req, res) => formidableHandle("engraveScm", req, res,
+			async ({source}) => {
+				const result = await lilyCommands.engraveScm(source, {includeFolders: constants.LY_INCLUDE_FOLDERS});
+				return JSON.stringify(result);
+			}),
+	},
+
+
+	"/engraveMIDI": {
+		post: (req, res) => formidableHandle("engraveMIDI", req, res,
+			async ({source, articulate = false}) => {
+				const lilyParser = await loadLilyParser();
+				const midi = await (articulate ? ScoreMaker.makeArticulatedMIDI(source, lilyParser, {includeFolders: constants.LY_INCLUDE_FOLDERS})
+					: ScoreMaker.makeMIDI(source, lilyParser, {includeFolders: constants.LY_INCLUDE_FOLDERS}));
+				const buffer = Buffer.from(MIDI.encodeMidiFile(midi));
+
+				return {
+					header: {
+						"Content-Type": "audio/midi",
+					},
+					body: buffer,
+				};
+			}),
+	},
+
+
+	"/advanced-engrave": {
+		post: (req, res) => new formidable.IncomingForm().parse(req, async (err, fields) => {
+			try {
+				if (err)
+					throw err;
+
+				const logger = new LogRecorder({enabled: !!fields.log});
+
+				const lilyParser = await loadLilyParser();
+
+				const task = advancedEngrave(fields.source, lilyParser, res, {
+					includeFolders: constants.LY_INCLUDE_FOLDERS,
+					withMIDI: !!fields.withMIDI,
+					withNotation: !!fields.withNotation,
+					withLilyDoc: !!fields.withLilyDoc,
+					withLilyNotation: !!fields.withLilyNotation,
+					logger,
+				});
+
+				res.writeHead(200);
+
+				await task;
+				res.end();
+			}
+			catch (err) {
+				console.warn("advanced-engrave error:", err);
+		
+				res.writeHead(500);
+				res.write(err.toString());
+				res.end();
+			}
+		}),
+	},
+};
+
+
+const setEnvironment = env => lilyCommands.setEnvironment(env);
+
+
+
+export {
+	setEnvironment,
+	service,
+	lilyCommands,
+	ScoreMaker,
+	advancedEngrave,
+};

backend/lilyAddon.ts

@@ -0,0 +1,104 @@
+
+import {Writable} from "stream";
+import {MIDI} from "@k-l-lambda/music-widgets";
+
+import {EngraverOptions, EngraverResult, postProcessSvg} from "./lilyCommands";
+
+
+
+let lilypondEx = null;
+
+const loadAddon = (path: string): boolean => {
+	lilypondEx = require(path);
+
+	return !!lilypondEx;
+};
+
+
+const engraveSvg = async (source: string,
+	{onProcStart, onMidiRead, onSvgRead, includeFolders = []}: EngraverOptions = {}): Promise<Partial<EngraverResult>> => {
+	if (!lilypondEx)
+		throw new Error("Lilypond addon not loaded.");
+
+	let logs;
+	const svgs = [];
+	let midi;
+
+	const engravePromise = lilypondEx.engrave(source, {
+		includeFolders,
+		log (message) {
+			logs = message;
+		},
+		onSVG (filename, content) {
+			const captures = filename.match(/-(\d+)\.svg$/);
+			const index = captures ? Number(captures[1]) - 1 : 0;
+
+			const svg = postProcessSvg(content);
+			svgs[index] = svg;
+
+			onSvgRead && onSvgRead(index, svg);
+		},
+		onMIDI (_, buffer) {
+			midi = MIDI.parseMidiData(buffer);
+
+			onMidiRead && onMidiRead(midi);
+		},
+	});
+
+	await onProcStart && onProcStart();
+
+	const errorLevel = await engravePromise;
+
+	return {
+		logs,
+		svgs,
+		midi,
+		errorLevel,
+	};
+};
+
+
+const engraveSvgWithStream = async (source: string,
+	output: Writable, {includeFolders = []}: {includeFolders?: string[]} = {},
+): Promise<Partial<EngraverResult>> => {
+	let logs;
+	//let midi;
+
+	//const tasks = [];
+
+	const errorLevel = await lilypondEx.engrave(source, {
+		includeFolders,
+		log (message) {
+			logs = message;
+		},
+		onSVG (_, content) {
+			// Write stream in non-main thread may result in blocking, so post a task to event looping.
+			//tasks.push(new Promise(resolve => ));
+			setImmediate(() => {
+				output.write(content);
+				output.write("\n\n\n\n");
+			});
+		},
+		//onMIDI (_, buffer) {
+		//	midi = MIDI.parseMidiData(buffer);
+		//},
+	});
+
+	//await Promise.all(tasks);
+	await new Promise(resolve => setImmediate(resolve));
+
+	return {
+		logs,
+		//midi,
+		errorLevel,
+	};
+};
+
+
+
+
+export {
+	loadAddon,
+	engraveSvg,
+	engraveSvgWithStream,
+};

backend/lilyCommands.ts

@@ -0,0 +1,438 @@
+
+
+import fs from "fs";
+import path from "path";
+import child_process from "child-process-promise";
+import {MIDI} from "@k-l-lambda/music-widgets";
+import {Writable} from "stream";
+
+import asyncCall from "../inc/asyncCall";
+import {SingleLock} from "../inc/mutex";
+import {preprocessXml} from "./xmlTools";
+import * as lilyAddon from "./lilyAddon";
+
+
+
+let MUSICXML2LY_PATH;
+let MIDI2LY_PATH;
+let LILYPOND_PATH;
+
+
+let env;	// setEnvironment must be called before use commands
+const setEnvironment = e => {
+	env = e;
+
+	MUSICXML2LY_PATH = filePathResolve(env.LILYPOND_DIR, "musicxml2ly");
+	MIDI2LY_PATH = filePathResolve(env.LILYPOND_DIR, "midi2ly");
+	LILYPOND_PATH = filePathResolve(env.LILYPOND_DIR, "lilypond");
+
+	emptyCache();
+
+	if (env.LILYPOND_ADDON) {
+		if (env.LILYPOND_ADDON_ASSETS_DIR) {
+			process.env.LILYPOND_PATH = path.join(env.LILYPOND_ADDON_ASSETS_DIR, "bin/lilypond");
+			process.env.GUILE_LOAD_PATH = path.join(env.LILYPOND_ADDON_ASSETS_DIR, "share/guile/1.8");
+			process.env.FONTCONFIG_PATH = path.join(env.LILYPOND_ADDON_ASSETS_DIR, "share/fonts");
+		}
+
+		lilyAddon.loadAddon(env.LILYPOND_ADDON);
+	}
+};
+
+
+const _WINDOWS = process.platform === "win32";
+
+
+const genHashString = (len = 8) => Buffer.from(Math.random().toString()).toString("base64").substr(3, 3 + len);
+
+
+const filePathResolve = (...parts: string[]): string => {
+	const result = path.join(...parts);
+	return _WINDOWS ? `"${result}"` : result;
+};
+
+
+const emptyCache = async () => {
+	// empty temporary directory
+	try {
+		if (env.TEMP_DIR) {
+			if (_WINDOWS)
+				await child_process.exec(`del /q "${env.TEMP_DIR}*"`);
+			else
+				await child_process.exec(`rm ${env.TEMP_DIR}*`);
+			console.log("Temporary directory clear.");
+		}
+	}
+	catch (err) {
+		if (_WINDOWS)
+			console.log("emptyCache error:", err);
+	}
+};
+
+
+export interface LilyProcessOptions {
+	// xml
+	language?: string;
+	removeMeasureImplicit?: boolean;
+	replaceEncoding?: boolean;
+	removeNullDynamics?: boolean;
+	fixHeadMarkup?: boolean;
+	fixBackSlashes?: boolean;
+	roundTempo?: boolean;
+	escapedWordsDoubleQuotation?: boolean;
+	removeTrivialRests?: boolean;
+	removeBadMetronome?: boolean;
+	removeInvalidHarmonies?: boolean;
+	removeAllHarmonies?: boolean;
+	fixChordVoice?: boolean;
+	fixBarlines?: boolean;
+	removeInvalidClef?: boolean;
+
+	// lilypond
+	pointClick?: boolean;
+	midi?: boolean;
+	removeBreak?: boolean;
+	removePageBreak?: boolean;
+	removeInstrumentName?: boolean;
+	removeTempo?: boolean;
+	tupletReplace?: boolean;
+};
+
+
+
+
+const postProcessLy = (ly: string, {
+	pointClick = true,
+	midi = true,
+	removeBreak = false,
+	removePageBreak = false,
+	removeInstrumentName = false,
+	removeTempo = false,
+	tupletReplace = false,
+} = {}): string => {
+	let result = ly;
+
+	if (pointClick)
+		result = result.replace(/\\pointAndClickOff\n/g, "");
+
+	if (midi)
+		result = result.replace(/%  \\midi/g, "\\midi");
+
+	if (removeBreak)
+		result = result.replace(/\s\\break\s/g, " ");
+
+	if (removePageBreak)
+		result = result.replace(/\s\\pageBreak\s/g, " ");
+
+	if (removeInstrumentName)
+		result = result.replace(/\\set Staff\.instrumentName/g, "% \\set Staff.instrumentName");
+
+	if (removeTempo)
+		result = result.replace(/\\tempo /g, "% \\tempo ");
+
+	if (tupletReplace) {
+		result = result
+			.replace(/4\*128\/384/g, "8*2/3")
+			.replace(/4\*64\/384/g, "16*2/3");
+	}
+
+	return result;
+};
+
+
+const xml2ly = async (xml: string, {language = "english", ...options}: LilyProcessOptions): Promise<string> => {
+	xml = preprocessXml(xml, options);
+	//console.log("xml:", options, xml.substr(0, 100));
+
+	const hash = genHashString();
+	const xmlFileName = `${env.TEMP_DIR}xml2ly-${hash}.xml`;
+	await asyncCall(fs.writeFile, xmlFileName, xml);
+
+	const lyFileName = `${env.TEMP_DIR}xml2ly-${hash}.ly`;
+
+	if (env.MUSICXML2LY_BY_PYTHON) {
+		await child_process.spawn(path.resolve(env.LILYPOND_DIR, "python"), [
+			path.resolve(env.LILYPOND_DIR, "musicxml2ly.py"), xmlFileName, "-o", lyFileName,
+			...(language ? ["-l", language] : []),
+		]);
+	}
+	else
+		await child_process.exec(`${MUSICXML2LY_PATH} ${xmlFileName} -o ${lyFileName} ${language ? "-l " + language : ""}`, {maxBuffer: 0x80000});
+	//console.log("musicxml2ly:", result.stdout, result.stderr);
+
+	const ly = await asyncCall(fs.readFile, lyFileName);
+
+	return postProcessLy(ly.toString(), options);
+};
+
+
+const midi2ly = async (midi, options: LilyProcessOptions): Promise<string> => {
+	const hash = genHashString();
+	//const midiFileName = `${env.TEMP_DIR}midi2ly-${hash}.midi`;
+	//await asyncCall(fs.writeFile, midiFileName, midi);
+
+	const lyFileName = `${env.TEMP_DIR}midi2ly-${hash}-midi.ly`;
+
+	let result;
+	if (env.MUSICXML2LY_BY_PYTHON) {
+		result = await child_process.spawn(path.resolve(env.LILYPOND_DIR, "python"),
+			[path.resolve(env.LILYPOND_DIR, "midi2ly.py"), midi.path, "-o", lyFileName]);
+	}
+	else
+		result = await child_process.exec(`${MIDI2LY_PATH} ${midi.path} -o ${lyFileName}`);
+	console.log("midi2ly:", result.stdout, result.stderr);
+
+	const ly = await asyncCall(fs.readFile, lyFileName);
+
+	return postProcessLy(ly.toString(), options);
+};
+
+
+const postProcessSvg = (svg: string): string => {
+	return svg.replace(/textedit:[^"]+:(\d+:\d+:\d+)/g, "textedit:$1");
+};
+
+
+//const nameNumber = name => Number(name.match(/-(\d+)\./)[1]);
+
+
+// lilypond command line output file pattern
+const FILE_BORN_OUPUT_PATTERN = /output\sto\s`(.+)'/;
+
+
+export interface EngraverOptions {
+	onProcStart?: () => void|Promise<void>;
+	onMidiRead?: (content: MIDI.MidiData, options?: {filePath: string}) => void|Promise<void>;
+	onSvgRead?: (index: number, content: string, options?: {filePath: string}) => void|Promise<void>;
+	includeFolders?: string[];	// include folder path should be relative to TEMP_DIR
+};
+
+export interface EngraverResult {
+	logs: string;
+	svgs: string[];
+	midi: MIDI.MidiData;
+	errorLevel: number;
+};
+
+
+const engraveSvgCli = async (source: string,
+	{onProcStart, onMidiRead, onSvgRead, includeFolders = []}: EngraverOptions = {},
+): Promise<Partial<EngraverResult>> => {
+	const hash = genHashString();
+	const sourceFilename = `${env.TEMP_DIR}engrave-${hash}.ly`;
+
+	await asyncCall(fs.writeFile, sourceFilename, source);
+	//console.log("ly source written:", sourceFilename);
+
+	let midi = null;
+	const svgs = [];
+
+	const fileReady = new SingleLock<string>();
+
+	const loadFile = async filename => {
+		//console.log("loadFile:", filename);
+
+		// wait for file writing finished
+		//await new Promise(resolve => setTimeout(resolve, 100));
+
+		const captures = filename.match(/\.(\w+)$/);
+		if (!captures) {
+			console.warn("invalid filename:", filename);
+			return;
+		}
+		const [_, ext] = captures;
+
+		const filePath = path.resolve(env.TEMP_DIR, filename);
+		//console.log("file output:", filePath, ext);
+
+		switch (ext) {
+		case env.MIDI_FILE_EXTEND: {
+			// wait extra time for MIDI file
+			//await fileReady.lock();
+			await new Promise(resolve => setTimeout(resolve, 100));
+
+			const buffer = await asyncCall(fs.readFile, filePath);
+			if (!buffer.length)
+				console.warn("empty MIDI buffer:", filename);
+
+			midi = MIDI.parseMidiData(buffer);
+
+			await onMidiRead && onMidiRead(midi, {filePath});
+		}
+
+			break;
+		case "svg": {
+			// eslint-disable-next-line
+			const captures = filename.match(/(\d+)\.svg$/);
+			const index = captures ? Number(captures[1]) - 1 : 0;
+
+			const buffer = await asyncCall(fs.readFile, filePath);
+			if (!buffer.length)
+				console.warn("empty SVG buffer:", filename);
+
+			const svg = postProcessSvg(buffer.toString());
+			svgs[index] = svg;
+
+			//console.log("svg load:", filePath);
+			await onSvgRead && onSvgRead(index, svg, {filePath});
+		}
+
+			break;
+		}
+	};
+
+	const loadProcs: Promise<void>[] = [];
+
+	const checkFile = async (line: string) => {
+		fileReady.release(line);
+
+		// skip error messages in command line output
+		if (FILE_BORN_OUPUT_PATTERN.test(line)) {
+			let newLine = await fileReady.lock();
+			while (/error|warning/.test(newLine))
+				newLine = await fileReady.lock();
+
+			let captures;
+			const exp = new RegExp(FILE_BORN_OUPUT_PATTERN.source, "g");
+			while (captures = exp.exec(line))
+				loadProcs.push(loadFile(captures[1]));
+		}
+	};
+
+	const includeParameters = includeFolders.map(folder => `--include=${folder}`).join(" ");
+
+	const proc: any = child_process.exec(`${LILYPOND_PATH} -dbackend=svg -o ${env.TEMP_DIR} ${includeParameters} ${sourceFilename}`,
+		{maxBuffer: 0x100000});
+	//const proc = child_process.spawn(LILYPOND_PATH, ["-dbackend=svg", `-o ${env.TEMP_DIR}`, sourceFilename]);
+	proc.childProcess.stdout.on("data", checkFile);
+	proc.childProcess.stderr.on("data", checkFile);
+
+	const startPromise = onProcStart && onProcStart();
+	if (startPromise)
+		loadProcs.push(startPromise);
+
+	const result = await proc;
+
+	fileReady.release();
+
+	await Promise.all(loadProcs);
+
+	//console.log("svgs:", svgs.length);
+
+	const validCount = svgs.filter(svg => svg).length;
+	if (validCount < svgs.length)
+		console.warn("svg loading incompleted: ", validCount, svgs.length);
+
+	return {
+		logs: result.stderr,
+		svgs,
+		midi,
+	};
+};
+
+
+const engraveSvgWithStreamCli = async (source: string, output: Writable, {includeFolders = []}: {includeFolders?: string[]} = {}) => {
+	const hash = genHashString();
+	const sourceFilename = `${env.TEMP_DIR}engrave-${hash}.ly`;
+
+	await asyncCall(fs.writeFile, sourceFilename, source);
+
+	const writing = new SingleLock();
+	const fileReady = new SingleLock();
+
+	const loadFile = async line => {
+		const [_, filename] = line.match(FILE_BORN_OUPUT_PATTERN);
+		const [__, ext] = filename.match(/\.(\w+)$/);
+
+		switch (ext) {
+		case "svg": {
+			await fileReady.lock();
+			await writing.wait();
+	
+			writing.lock();
+
+			const filePath = path.resolve(env.TEMP_DIR, filename);
+			const fileStream = fs.createReadStream(filePath);
+			fileStream.pipe(output, {end: false});
+
+			fileStream.on("close", () => output.write("\n\n\n\n"));
+
+			writing.release();
+		}
+
+			break;
+		}
+	};
+
+	const checkFile = line => {
+		fileReady.release();
+
+		if (FILE_BORN_OUPUT_PATTERN.test(line))
+			loadFile(line);
+	};
+
+	const includeParameters = includeFolders.map(folder => `--include=${folder}`).join(" ");
+
+	const proc: any = child_process.exec(`${LILYPOND_PATH} -dbackend=svg -o ${env.TEMP_DIR} ${includeParameters} ${sourceFilename}`);
+	proc.childProcess.stdout.on("data", checkFile);
+	proc.childProcess.stderr.on("data", checkFile);
+
+	proc.then(() => fileReady.release());
+
+	return proc;
+};
+
+
+const engraveScm = async (source: string, {onProcStart, includeFolders = []}: {
+	onProcStart?: () => void|Promise<void>,
+	includeFolders?: string[],	// include folder path should be relative to TEMP_DIR
+} = {}): Promise<{
+	logs: string,
+	scm: string,
+}> => {
+	const hash = genHashString();
+	const sourceFilename = `${env.TEMP_DIR}engrave-${hash}.ly`;
+	const targetFilename = `${env.TEMP_DIR}engrave-${hash}.scm`;
+
+	await fs.promises.writeFile(sourceFilename, source);
+	//console.log("ly source written:", sourceFilename);
+
+	const includeParameters = includeFolders.map(folder => `--include=${folder}`).join(" ");
+
+	const proc = child_process.exec(`${LILYPOND_PATH} -dbackend=scm -o ${env.TEMP_DIR} ${includeParameters} ${sourceFilename}`,
+		{maxBuffer: 0x100000});
+
+	await onProcStart && onProcStart();
+
+	const result = await proc;
+
+	const scmBuffer = await fs.promises.readFile(targetFilename);
+
+	return {
+		logs: result.stderr,
+		scm: scmBuffer.toString(),
+	};
+};
+
+
+const engraveSvg = async (source: string, options: EngraverOptions = {}): Promise<Partial<EngraverResult>> =>
+	(env.LILYPOND_ADDON ? lilyAddon.engraveSvg : engraveSvgCli)(source, options);
+
+
+const engraveSvgWithStream = async (source: string, output: Writable, options: {includeFolders?: string[]} = {}) =>
+	(env.LILYPOND_ADDON ? lilyAddon.engraveSvgWithStream : engraveSvgWithStreamCli)(source, output, options);
+
+
+
+export {
+	xml2ly,
+	midi2ly,
+	engraveSvg,
+	engraveSvgCli,
+	engraveSvgWithStream,
+	engraveSvgWithStreamCli,
+	engraveScm,
+	setEnvironment,
+	emptyCache,
+	postProcessSvg,
+};

backend/loadJisonParserNode.ts

@@ -0,0 +1,22 @@
+
+import fs from "fs";
+
+import {Parser} from "../inc/jisonWrapper";
+
+
+
+const parsers = new Map<string, Parser>();
+
+
+
+export default async function load (jison): Promise<Parser> {
+	if (!parsers.get(jison)) {
+		const grammar = (await fs.promises.readFile(jison)).toString();
+
+		//console.log("grammar:", grammar);
+
+		parsers.set(jison, new Parser(grammar)) ;
+	}
+
+	return parsers.get(jison);
+};

backend/loadLilyParserNode.ts

@@ -0,0 +1,8 @@
+
+import loadJisonParser from "./loadJisonParserNode";
+
+import {Parser} from "../inc/jisonWrapper";
+
+
+
+export default (): Promise<Parser> => loadJisonParser("./jison/lilypond.jison");

backend/scoreMaker.ts

@@ -0,0 +1,359 @@
+
+import {DOMParser, XMLSerializer} from "xmldom";
+import {MusicNotation} from "@k-l-lambda/music-widgets";
+import {MIDI} from "@k-l-lambda/music-widgets";
+import {Readable} from "stream";
+import CRC32 from "crc-32";
+
+import npmPackage from "../package.json";
+import {xml2ly, engraveSvg, LilyProcessOptions} from "./lilyCommands";
+import {LilyDocument, LilyTerms, docLocationSet} from "../inc/lilyParser";
+import * as staffSvg from "../inc/staffSvg";
+import {SingleLock} from "../inc/mutex";
+import * as LilyNotation from "../inc/lilyNotation";
+import {svgToPng} from "./canvas";
+import LogRecorder from "../inc/logRecorder";
+import ScoreJSON from "../inc/scoreJSON";
+import {LilyDocumentAttributeReadOnly} from "../inc/lilyParser/lilyDocument";
+import {Block} from "../inc/lilyParser/lilyTerms";
+
+
+
+interface GrammarParser {
+	parse (source: string): any;
+};
+
+
+const markupLily = (source: string, markup: string, lilyParser: GrammarParser): string => {
+	const docMarkup = new LilyDocument(lilyParser.parse(markup));
+	const docSource = new LilyDocument(lilyParser.parse(source));
+
+	/*// copy attributes
+	const attrS = docSource.globalAttributes() as LilyDocumentAttribute;
+	const attrM = docMarkup.globalAttributes({readonly: true}) as LilyDocumentAttributeReadOnly;
+
+	[
+		"staffSize", "paperWidth", "paperHeight",
+		"topMargin", "bottomMargin", "leftMargin", "rightMargin",
+		"systemSpacing", "topMarkupSpacing", "raggedLast", "raggedBottom", "raggedLastBottom",
+		"printPageNumber",
+	].forEach(field => {
+		if (attrM[field] !== undefined) {
+			if (typeof attrS[field].value === "object" && attrS[field].value && (attrS[field].value as any).set)
+				(attrS[field].value as any).set(attrM[field]);
+			else
+				attrS[field].value = attrM[field];
+		}
+	});
+
+	// execute commands list
+	const commands = docMarkup.root.getField("LotusCommands");
+	const cmdList = commands && commands.value && commands.value.args && commands.value.args[0].body;
+	if (cmdList && Array.isArray(cmdList)) {
+		for (const command of cmdList) {
+			if (command.exp && docSource[command.exp])
+				docSource[command.exp]();
+			else
+				console.warn("unexpected markup command:", command);
+		}
+	}
+
+	// copy LotusOption assignments
+	const assignments = docMarkup.root.entries.filter(term => term instanceof LilyTerms.Assignment && /^LotusOption\..+/.test(term.key.toString()));
+	assignments.forEach(assignment => docSource.root.sections.push(assignment.clone()));*/
+	docSource.markup(docMarkup);
+
+	return docSource.toString();
+};
+
+
+const xmlBufferToLy = async (xml: Buffer, options: LilyProcessOptions = {}): Promise<string> => {
+	const bom = (xml[0] << 8 | xml[1]);
+	const utf16 = bom === 0xfffe;
+	const content = xml.toString(utf16 ? "utf16le" : "utf8");
+
+	return await xml2ly(content, {replaceEncoding: utf16, ...options});
+};
+
+
+const unescapeStringExp = exp => exp && exp.toString();
+
+
+interface SheetNotationResult extends Partial<ScoreJSON> {
+	midi: MIDI.MidiData;
+	midiNotation: MusicNotation.NotationData;
+	//sheetNotation: staffSvg.StaffNotation.SheetNotation;
+	lilyDocument: LilyDocument;
+	bakingImages?: Readable[];
+};
+
+
+const makeSheetNotation = async (source: string, lilyParser: GrammarParser, {withNotation = false, logger, lilyDocument, includeFolders, baking}: {
+	withNotation?: boolean,
+	logger?: LogRecorder,
+	lilyDocument?: LilyDocument,
+	includeFolders?: string[],
+	baking?: boolean,
+} = {}): Promise<SheetNotationResult> => {
+	let midi = null;
+	let midiNotation = null;
+
+	const pages = [];
+	const hashTable = {};
+	const bakingImages = [];
+
+	const t0 = Date.now();
+
+	type ParserArguments = {
+		attributes: LilyDocumentAttributeReadOnly,
+		tieLocations: Set<string>,
+		briefChordLocations: Set<string>,
+		lyricLocations: Set<string>,
+	};
+
+	const argsGen = new SingleLock<ParserArguments>(true);
+
+	const engraving = await engraveSvg(source, {
+		includeFolders,
+		// do some work during lilypond process running to save time
+		onProcStart: () => {
+			//console.log("tp.0:", Date.now() - t0);
+			if (!lilyDocument) {
+				lilyDocument = new LilyDocument(lilyParser.parse(source));
+				lilyDocument.interpret();
+			}
+
+			const attributes = lilyDocument.globalAttributes({readonly: true}) as LilyDocumentAttributeReadOnly;
+
+			const tieLocations = docLocationSet(lilyDocument.getTiedNoteLocations2());
+			const briefChordLocations = docLocationSet(lilyDocument.getBriefChordLocations());
+			const lyricLocations = docLocationSet(lilyDocument.getLyricLocations());
+
+			argsGen.release({attributes, tieLocations, briefChordLocations, lyricLocations});
+			//console.log("tp.1:", Date.now() - t0);
+		},
+		onMidiRead: midi_ => {
+			//console.log("tm.0:", Date.now() - t0);
+			midi = midi_;
+			if (withNotation)
+				midiNotation = midi && MusicNotation.Notation.parseMidi(midi);
+			//console.log("tm.1:", Date.now() - t0);
+		},
+		onSvgRead: async (index, svg) => {
+			//console.log("ts.0:", Date.now() - t0);
+			const args = await argsGen.wait();
+			const page = staffSvg.parseSvgPage(svg, source, {DOMParser, logger, ...args});
+			pages[index] = page.structure;
+			Object.assign(hashTable, page.hashTable);
+			//console.log("ts.1:", Date.now() - t0);
+		},
+	});
+
+	logger.append("scoreMaker.profile.engraving", {cost: Date.now() - t0});
+	logger.append("lilypond.log", engraving.logs);
+
+	const doc = new staffSvg.SheetDocument({pages});
+
+	staffSvg.postProcessSheetDocument(doc, lilyDocument);
+
+	if (baking) {
+		await Promise.all(engraving.svgs.map(async (svg, index) => {
+			const svgText = staffSvg.turnRawSvgWithSheetDocument(svg, pages[index], {DOMParser, XMLSerializer});
+			bakingImages[index] = await svgToPng(Buffer.from(svgText));
+		}));
+	}
+
+	const midiMusic = lilyDocument.interpret().midiMusic;
+
+	const {attributes} = await argsGen.wait();
+	const meta = {
+		title: unescapeStringExp(attributes.title),
+		composer: unescapeStringExp(attributes.composer),
+		pageSize: doc.pageSize,
+		pageCount: doc.pages.length,
+		staffSize: attributes.staffSize as number,
+		trackInfos: midiMusic && midiMusic.trackContextDicts,
+	};
+
+	/*const t00 = Date.now();
+	const sheetNotation = staffSvg.StaffNotation.parseNotationFromSheetDocument(doc, {logger});
+
+	// correct notation time by location-tick table from lily document
+	const tickTable = lilyDocument.getLocationTickTable();
+	staffSvg.StaffNotation.assignTickByLocationTable(sheetNotation, tickTable);
+	console.log("parseNotationFromSheetDocument cost:", Date.now() - t00);*/
+
+	return {
+		midi,
+		bakingImages: baking ? bakingImages : null,
+		midiNotation,
+		//sheetNotation,
+		meta,
+		doc,
+		hashTable,
+		lilyDocument,
+	};
+};
+
+
+interface MakerOptions {
+	midi: MIDI.MidiData;
+	logger: LogRecorder;
+	includeFolders: string[];
+	baking: boolean;
+	ignoreNotation: boolean;
+};
+
+
+interface MakerResult {
+	bakingImages?: Readable[],
+	score: Partial<ScoreJSON>,
+};
+
+
+// non-negative crc-32
+const hashString = (str: string): number => {
+	const value = CRC32.str(str);
+	return value < 0 ? 0x100000000 + value : value;
+};
+
+
+const makeScore = async (
+	source: string,
+	lilyParser: GrammarParser,
+	{midi, logger, baking = false, includeFolders, ignoreNotation = false}: Partial<MakerOptions> = {},
+): Promise<MakerResult> => {
+	const t0 = Date.now();
+
+	const hash = hashString(source);
+
+	const foldData = await makeSheetNotation(source, lilyParser, {logger, includeFolders, baking});
+	const {meta, doc, hashTable, bakingImages, lilyDocument} = foldData;
+
+	midi = midi || foldData.midi;
+	const lilyNotation = !ignoreNotation && lilyDocument.interpret().getNotation();
+
+	if (ignoreNotation || !midi || !lilyNotation) {
+		if (!ignoreNotation) {
+			if (!midi)
+				console.warn("Neither lilypond or external arguments did not offer MIDI data, score maker finished incompletely.");
+
+			if (!lilyNotation)
+				console.warn("lilyNotation parsing failed, score maker finished incompletely.");
+		}
+
+		return {
+			score: {
+				version: npmPackage.version,
+				hash,
+				meta,
+				doc,
+				hashTable,
+			},
+		};
+	}
+
+	const t5 = Date.now();
+
+	const matcher = await LilyNotation.matchWithExactMIDI(lilyNotation, midi);
+
+	logger.append("scoreMaker.profile.matching", {cost: Date.now() - t5});
+
+	if (logger && logger.enabled) {
+		const cis = new Set(Array(matcher.criterion.notes.length).keys());
+		matcher.path.forEach(ci => cis.delete(ci));
+
+		const omitC = cis.size;
+		const omitS = matcher.path.filter(ci => ci < 0).length;
+
+		const coverage = ((matcher.criterion.notes.length - omitC) / matcher.criterion.notes.length)
+			* ((matcher.sample.notes.length - omitS) / matcher.sample.notes.length);
+
+		logger.append("makeScore.match", {coverage, omitC, omitS, path: matcher.path});
+	}
+
+	doc.updateMatchedTokens(lilyNotation.idSet);
+
+	// idTrackMap is useless in bundled score
+	delete lilyNotation.idTrackMap;
+
+	if (baking)
+		doc.pruneForBakingMode();
+
+	logger.append("scoreMaker.profile.full", {cost: Date.now() - t0});
+
+	return {
+		bakingImages,
+		score: {
+			version: npmPackage.version,
+			hash,
+			meta,
+			doc,
+			hashTable: !baking ? hashTable : null,
+			lilyNotation,
+		},
+	};
+};
+
+
+const makeMIDI = async (source: string, lilyParser: GrammarParser, {unfoldRepeats = false, fixNestedRepeat = false, includeFolders = undefined} = {}): Promise<MIDI.MidiData> => {
+	const lilyDocument = new LilyDocument(lilyParser.parse(source));
+
+	if (fixNestedRepeat)
+		lilyDocument.fixNestedRepeat();
+
+	if (unfoldRepeats)
+		lilyDocument.unfoldRepeats();
+
+	const score = lilyDocument.root.getBlock("score");
+	if (score) {
+		// remove layout block to save time
+		score.body = score.body.filter(term => !(term instanceof LilyTerms.Block && term.head === "\\layout"));
+
+		// remove invalid tempo
+		const midi: any = score.body.find(term => term instanceof LilyTerms.Block && term.head === "\\midi");
+		if (midi)
+			midi.body = midi.body.filter(term => !(term instanceof LilyTerms.Tempo && term.beatsPerMinute > 200));
+	}
+
+	const markupSource = lilyDocument.toString();
+	//console.log("markupSource:", markupSource);
+
+	return new Promise((resolve, reject) => engraveSvg(markupSource, {
+		includeFolders,
+		onMidiRead: resolve,
+	}).catch(reject));
+};
+
+
+const makeArticulatedMIDI = async (source: string, lilyParser: GrammarParser, {ignoreRepeats = true, includeFolders = undefined} = {}): Promise<MIDI.MidiData> => {
+	const lilyDocument = new LilyDocument(lilyParser.parse(source));
+
+	if (ignoreRepeats)
+		lilyDocument.removeRepeats();
+
+	lilyDocument.articulateMIDIOutput();
+
+	// remove layout block to save time
+	lilyDocument.root.sections = lilyDocument.root.sections.filter(section => !(section instanceof Block)
+		|| !(section.head === "\\score")
+		|| section.isMIDIDedicated);
+
+	const markupSource = lilyDocument.toString();
+	//console.log("markupSource:", markupSource);
+
+	return new Promise((resolve, reject) => engraveSvg(markupSource, {
+		includeFolders,
+		onMidiRead: resolve,
+	}).catch(reject));
+};
+
+
+
+export {
+	markupLily,
+	xmlBufferToLy,
+	makeScore,
+	makeMIDI,
+	makeArticulatedMIDI,
+};

backend/scoreMaker.ts.old

@@ -0,0 +1,665 @@
+//
+// OBSOLETE code, only for archive
+//
+
+import _ from "lodash";
+import {DOMParser, XMLSerializer} from "xmldom";
+import {MusicNotation} from "@k-l-lambda/music-widgets";
+import {MIDI} from "@k-l-lambda/music-widgets";
+import {Readable} from "stream";
+
+import npmPackage from "../package.json";
+import {xml2ly, engraveSvg, LilyProcessOptions} from "./lilyCommands";
+import {LilyDocument, replaceSourceToken, LilyTerms} from "../inc/lilyParser";
+import * as staffSvg from "../inc/staffSvg";
+import {SingleLock} from "../inc/mutex";
+import {PitchContextTable} from "../inc/pitchContext";
+import * as LilyNotation from "../inc/lilyNotation";
+import {svgToPng} from "./canvas";
+import LogRecorder from "../inc/logRecorder";
+import ScoreJSON, {NoteLinking} from "../inc/scoreJSON";
+import {LilyDocumentAttribute, LilyDocumentAttributeReadOnly} from "../inc/lilyParser/lilyDocument";
+import {Block} from "../inc/lilyParser/lilyTerms";
+
+
+
+interface GrammarParser {
+	parse (source: string): any;
+};
+
+
+const markupLily = (source: string, markup: string, lilyParser: GrammarParser): string => {
+	const docMarkup = new LilyDocument(lilyParser.parse(markup));
+	const docSource = new LilyDocument(lilyParser.parse(source));
+
+	// copy attributes
+	const attrS = docSource.globalAttributes() as LilyDocumentAttribute;
+	const attrM = docMarkup.globalAttributes({readonly: true}) as LilyDocumentAttributeReadOnly;
+
+	[
+		"staffSize", "paperWidth", "paperHeight",
+		"topMargin", "bottomMargin", "leftMargin", "rightMargin",
+		"systemSpacing", "topMarkupSpacing", "raggedLast", "raggedBottom", "raggedLastBottom",
+		"printPageNumber",
+	].forEach(field => {
+		if (attrM[field] !== undefined) {
+			if (typeof attrS[field].value === "object" && attrS[field].value && (attrS[field].value as any).set)
+				(attrS[field].value as any).set(attrM[field]);
+			else
+				attrS[field].value = attrM[field];
+		}
+	});
+
+	// execute commands list
+	const commands = docMarkup.root.getField("LotusCommands");
+	const cmdList = commands && commands.value && commands.value.args && commands.value.args[0].body;
+	if (cmdList && Array.isArray(cmdList)) {
+		for (const command of cmdList) {
+			if (command.exp && docSource[command.exp])
+				docSource[command.exp]();
+			else
+				console.warn("unexpected markup command:", command);
+		}
+	}
+
+	// copy LotusOption assignments
+	const assignments = docMarkup.root.entries.filter(term => term instanceof LilyTerms.Assignment && /^LotusOption\..+/.test(term.key.toString()));
+	assignments.forEach(assignment => docSource.root.sections.push(assignment.clone()));
+
+	return docSource.toString();
+};
+
+
+const xmlBufferToLy = async (xml: Buffer, options: LilyProcessOptions = {}): Promise<string> => {
+	const bom = (xml[0] << 8 | xml[1]);
+	const utf16 = bom === 0xfffe;
+	const content = xml.toString(utf16 ? "utf16le" : "utf8");
+
+	return await xml2ly(content, {replaceEncoding: utf16, ...options});
+};
+
+
+const unescapeStringExp = exp => exp && exp.toString();
+
+
+const makeScoreV1 = async (source: string, lilyParser: GrammarParser, {midi, logger}: {midi?: MIDI.MidiData, logger?: LogRecorder} = {}): Promise<ScoreJSON> => {
+	const t0 = Date.now();
+
+	const engraving = await engraveSvg(source);
+
+	logger.append("scoreMaker.profile.engraving", {cost: Date.now() - t0});
+	logger.append("lilypond.log", engraving.logs);
+
+	const lilyDocument = new LilyDocument(lilyParser.parse(source));
+	const {doc, hashTable} = staffSvg.createSheetDocumentFromSvgs(engraving.svgs, source, lilyDocument, {logger, DOMParser});
+
+	const sheetNotation = staffSvg.StaffNotation.parseNotationFromSheetDocument(doc, {logger});
+
+	const attributes = lilyDocument.globalAttributes({readonly: true});
+
+	const meta = {
+		title: unescapeStringExp(attributes.title),
+		composer: unescapeStringExp(attributes.composer),
+		pageSize: doc.pageSize,
+		pageCount: doc.pages.length,
+		staffSize: attributes.staffSize as number,
+	};
+
+	midi = midi || engraving.midi;
+	const midiNotation = MusicNotation.Notation.parseMidi(midi);
+
+	const t5 = Date.now();
+
+	const matcher = await staffSvg.StaffNotation.matchNotations(midiNotation, sheetNotation);
+
+	logger.append("scoreMaker.profile.matching", {cost: Date.now() - t5});
+
+	if (logger) {
+		const cis = new Set(Array(matcher.criterion.notes.length).keys());
+		matcher.path.forEach(ci => cis.delete(ci));
+
+		const omitC = cis.size;
+		const omitS = matcher.path.filter(ci => ci < 0).length;
+
+		const coverage = ((matcher.criterion.notes.length - omitC) / matcher.criterion.notes.length)
+			* ((matcher.sample.notes.length - omitS) / matcher.sample.notes.length);
+
+		logger.append("makeScore.match", {coverage, omitC, omitS, path: matcher.path});
+	}
+
+	const matchedIds: Set<string> = new Set();
+	midiNotation.notes.forEach(note => note.ids && note.ids.forEach(id => matchedIds.add(id)));
+
+	doc.updateMatchedTokens(matchedIds);
+
+	const pitchContextGroup = PitchContextTable.createPitchContextGroup(sheetNotation.pitchContexts, midiNotation);
+
+	const noteLinkings = midiNotation.notes.map(note => _.pick(note, ["ids", "staffTrack", "contextIndex"]) as NoteLinking);
+
+	logger.append("scoreMaker.profile.full", {cost: Date.now() - t0});
+
+	return {
+		meta,
+		doc,
+		midi,
+		hashTable,
+		noteLinkings,
+		pitchContextGroup,
+	};
+};
+
+
+interface IncompleteScoreJSON {
+	meta?: any,
+	doc?: any;
+	hashTable?: {[key: string]: any};
+	midi?: MIDI.MidiData;
+	noteLinkings?: NoteLinking;
+	pitchContextGroup?: any;
+};
+
+
+interface SheetNotationResult extends IncompleteScoreJSON {
+	midiNotation: MusicNotation.NotationData;
+	sheetNotation: staffSvg.StaffNotation.SheetNotation;
+	lilyDocument: LilyDocument;
+	bakingImages?: Readable[];
+};
+
+
+const makeScoreV2 = async (source: string, lilyParser: GrammarParser, {midi, logger}: {midi?: MIDI.MidiData, logger?: LogRecorder} = {}): Promise<ScoreJSON | IncompleteScoreJSON> => {
+	let midiNotation = null;
+
+	const pages = [];
+	const hashTable = {};
+
+	const t0 = Date.now();
+
+	const attrGen = new SingleLock<LilyDocumentAttributeReadOnly>(true);
+
+	const engraving = await engraveSvg(source, {
+		// do some work during lilypond process running to save time
+		onProcStart: () => {
+			//console.log("tp.0:", Date.now() - t0);
+			const lilyDocument = new LilyDocument(lilyParser.parse(source));
+			attrGen.release(lilyDocument.globalAttributes({readonly: true}) as LilyDocumentAttributeReadOnly);
+			//console.log("tp.1:", Date.now() - t0);
+		},
+		onMidiRead: midi_ => {
+			//console.log("tm.0:", Date.now() - t0);
+			if (!midi) {
+				midi = midi_;
+				midiNotation = midi && MusicNotation.Notation.parseMidi(midi);
+			}
+			//console.log("tm.1:", Date.now() - t0);
+		},
+		onSvgRead: async svg => {
+			//console.log("ts.0:", Date.now() - t0);
+			const attributes = await attrGen.wait();
+			const page = staffSvg.parseSvgPage(svg, source, {DOMParser, logger, attributes});
+			pages.push(page.structure);
+			Object.assign(hashTable, page.hashTable);
+			//console.log("ts.1:", Date.now() - t0);
+		},
+	});
+
+	//console.log("t2:", Date.now() - t0);
+
+	logger.append("scoreMaker.profile.engraving", {cost: Date.now() - t0});
+	logger.append("lilypond.log", engraving.logs);
+
+	const doc = new staffSvg.SheetDocument({pages});
+
+	//console.log("t3:", Date.now() - t0);
+
+	const attributes = await attrGen.wait();
+	const meta = {
+		title: unescapeStringExp(attributes.title),
+		composer: unescapeStringExp(attributes.composer),
+		pageSize: doc.pageSize,
+		pageCount: doc.pages.length,
+		staffSize: attributes.staffSize,
+	};
+
+	if (!midiNotation) {
+		console.warn("Neither lilypond or external arguments did not offer MIDI data, score maker finish incompletely.");
+		return {
+			meta,
+			doc,
+			midi,
+			hashTable,
+		}; 
+	}
+
+	//console.log("t4:", Date.now() - t0);
+
+	const sheetNotation = staffSvg.StaffNotation.parseNotationFromSheetDocument(doc, {logger});
+
+	//console.log("t5:", Date.now() - t0);
+	const t5 = Date.now();
+
+	const matcher = await staffSvg.StaffNotation.matchNotations(midiNotation, sheetNotation);
+
+	//console.log("t6:", Date.now() - t0);
+	logger.append("scoreMaker.profile.matching", {cost: Date.now() - t5});
+
+	if (logger) {
+		const cis = new Set(Array(matcher.criterion.notes.length).keys());
+		matcher.path.forEach(ci => cis.delete(ci));
+
+		const omitC = cis.size;
+		const omitS = matcher.path.filter(ci => ci < 0).length;
+
+		const coverage = ((matcher.criterion.notes.length - omitC) / matcher.criterion.notes.length)
+			* ((matcher.sample.notes.length - omitS) / matcher.sample.notes.length);
+
+		logger.append("markScore.match", {coverage, omitC, omitS, path: matcher.path});
+	}
+
+	//console.log("t7:", Date.now() - t0);
+
+	const matchedIds: Set<string> = new Set();
+	midiNotation.notes.forEach(note => note.ids && note.ids.forEach(id => matchedIds.add(id)));
+
+	//console.log("t8:", Date.now() - t0);
+
+	doc.updateMatchedTokens(matchedIds);
+
+	//console.log("t9:", Date.now() - t0);
+
+	const pitchContextGroup = PitchContextTable.createPitchContextGroup(sheetNotation.pitchContexts, midiNotation);
+
+	//console.log("t10:", Date.now() - t0);
+
+	const noteLinkings = midiNotation.notes.map(note => _.pick(note, ["ids", "staffTrack", "contextIndex"]));
+
+	//console.log("t11:", Date.now() - t0);
+	logger.append("scoreMaker.profile.full", {cost: Date.now() - t0});
+
+	return {
+		meta,
+		doc,
+		midi,
+		hashTable,
+		noteLinkings,
+		pitchContextGroup,
+	};
+};
+
+
+const makeSheetNotation = async (source: string, lilyParser: GrammarParser, {withNotation = true, logger, lilyDocument, includeFolders, baking}: {
+	withNotation?: boolean,
+	logger?: LogRecorder,
+	lilyDocument?: LilyDocument,
+	includeFolders?: string[],
+	baking?: boolean,
+} = {}): Promise<SheetNotationResult> => {
+	let midi = null;
+	let midiNotation = null;
+
+	const pages = [];
+	const hashTable = {};
+	const bakingImages = [];
+
+	const t0 = Date.now();
+
+	type ParserArguments = {attributes: LilyDocumentAttributeReadOnly, tieLocations: {[key: string]: boolean}};
+
+	const argsGen = new SingleLock<ParserArguments>(true);
+
+	const engraving = await engraveSvg(source, {
+		includeFolders,
+		// do some work during lilypond process running to save time
+		onProcStart: () => {
+			//console.log("tp.0:", Date.now() - t0);
+			if (!lilyDocument) {
+				lilyDocument = new LilyDocument(lilyParser.parse(source));
+				lilyDocument.interpret();
+			}
+
+			const attributes = lilyDocument.globalAttributes({readonly: true}) as LilyDocumentAttributeReadOnly;
+
+			//const tieLocations = lilyDocument.getTiedNoteLocations(text)
+			const tieLocations = lilyDocument.getTiedNoteLocations2()
+				.reduce((table, loc) => ((table[`${loc[0]}:${loc[1]}`] = true), table), {});
+
+			argsGen.release({attributes, tieLocations});
+			//console.log("tp.1:", Date.now() - t0);
+		},
+		onMidiRead: withNotation && (midi_ => {
+			//console.log("tm.0:", Date.now() - t0);
+			midi = midi_;
+			midiNotation = midi && MusicNotation.Notation.parseMidi(midi);
+			//console.log("tm.1:", Date.now() - t0);
+		}),
+		onSvgRead: async (index, svg) => {
+			//console.log("ts.0:", Date.now() - t0);
+			const args = await argsGen.wait();
+			const page = staffSvg.parseSvgPage(svg, source, {DOMParser, logger, ...args});
+			pages[index] = page.structure;
+			Object.assign(hashTable, page.hashTable);
+			//console.log("ts.1:", Date.now() - t0);
+		},
+	});
+
+	logger.append("scoreMaker.profile.engraving", {cost: Date.now() - t0});
+	logger.append("lilypond.log", engraving.logs);
+
+	const doc = new staffSvg.SheetDocument({pages});
+
+	staffSvg.postProcessSheetDocument(doc, lilyDocument);
+
+	if (baking) {
+		await Promise.all(engraving.svgs.map(async (svg, index) => {
+			const svgText = staffSvg.turnRawSvgWithSheetDocument(svg, pages[index], {DOMParser, XMLSerializer});
+			bakingImages[index] = await svgToPng(Buffer.from(svgText));
+		}));
+	}
+
+	const {attributes} = await argsGen.wait();
+	const meta = {
+		title: unescapeStringExp(attributes.title),
+		composer: unescapeStringExp(attributes.composer),
+		pageSize: doc.pageSize,
+		pageCount: doc.pages.length,
+		staffSize: attributes.staffSize,
+	};
+
+	const sheetNotation = staffSvg.StaffNotation.parseNotationFromSheetDocument(doc, {logger});
+
+	// correct notation time by location-tick table from lily document
+	const tickTable = lilyDocument.getLocationTickTable();
+	staffSvg.StaffNotation.assignTickByLocationTable(sheetNotation, tickTable);
+
+	return {
+		midi,
+		bakingImages: baking ? bakingImages : null,
+		midiNotation,
+		sheetNotation,
+		meta,
+		doc,
+		hashTable,
+		lilyDocument,
+	};
+};
+
+
+const makeScoreV3 = async (source: string, lilyParser: GrammarParser, {midi, logger, unfoldRepeats = false, includeFolders}: {
+	midi?: MIDI.MidiData,
+	logger?: LogRecorder,
+	unfoldRepeats?: boolean,
+	includeFolders?: string[],
+} = {}): Promise<ScoreJSON | IncompleteScoreJSON> => {
+	const t0 = Date.now();
+
+	let lilyDocument = null;
+	let unfoldSource = null;
+
+	if (unfoldRepeats) {
+		lilyDocument = new LilyDocument(lilyParser.parse(source));
+		lilyDocument.interpret();
+		if (lilyDocument.containsRepeat()) {
+			lilyDocument.unfoldRepeats();
+			unfoldSource = lilyDocument.toString();
+
+			// keep 2 version lilypond source note href uniform
+			source = replaceSourceToken(unfoldSource, "\\unfoldRepeats");
+		}
+	}
+
+	const foldData = await makeSheetNotation(source, lilyParser, {logger, lilyDocument, withNotation: !midi && !unfoldSource, includeFolders});
+	const {meta, doc, hashTable} = foldData;
+
+	lilyDocument = lilyDocument || foldData.lilyDocument;
+	let midiNotation = foldData.midiNotation;
+	let sheetNotation = foldData.sheetNotation;
+
+	if (midi)
+		midiNotation = MusicNotation.Notation.parseMidi(midi);
+
+	if (unfoldSource) {
+		const unfoldData = await makeSheetNotation(unfoldSource, lilyParser, {logger, lilyDocument, withNotation: !midi, includeFolders});
+
+		midi = midi || unfoldData.midi;
+		midiNotation = unfoldData.midiNotation;
+		sheetNotation = unfoldData.sheetNotation;
+	}
+
+	midi = midi || foldData.midi;
+	if (!midi || !sheetNotation) {
+		if (!midi)
+			console.warn("Neither lilypond or external arguments did not offer MIDI data, score maker finished incompletely.");
+
+		if (!sheetNotation)
+			console.warn("sheetNotation parsing failed, score maker finished incompletely.");
+
+		return {
+			meta,
+			doc,
+			midi,
+			hashTable,
+		};
+	}
+
+	const t5 = Date.now();
+
+	const matcher = await staffSvg.StaffNotation.matchNotations(midiNotation, sheetNotation);
+
+	logger.append("scoreMaker.profile.matching", {cost: Date.now() - t5});
+
+	if (logger && logger.enabled) {
+		const cis = new Set(Array(matcher.criterion.notes.length).keys());
+		matcher.path.forEach(ci => cis.delete(ci));
+
+		const omitC = cis.size;
+		const omitS = matcher.path.filter(ci => ci < 0).length;
+
+		const coverage = ((matcher.criterion.notes.length - omitC) / matcher.criterion.notes.length)
+			* ((matcher.sample.notes.length - omitS) / matcher.sample.notes.length);
+
+		logger.append("makeScore.match", {coverage, omitC, omitS, path: matcher.path});
+	}
+
+	const matchedIds: Set<string> = new Set();
+	midiNotation.notes.forEach(note => note.ids && note.ids.forEach(id => matchedIds.add(id)));
+
+	doc.updateMatchedTokens(matchedIds);
+
+	const pitchContextGroup = PitchContextTable.createPitchContextGroup(sheetNotation.pitchContexts, midiNotation);
+
+	const noteLinkings = midiNotation.notes.map(note => _.pick(note, ["ids", "staffTrack", "contextIndex"]) as NoteLinking);
+
+	logger.append("scoreMaker.profile.full", {cost: Date.now() - t0});
+
+	return {
+		meta,
+		doc,
+		midi,
+		hashTable,
+		noteLinkings,
+		pitchContextGroup,
+	};
+};
+
+
+const makeScoreV4 = async (source: string, lilyParser: GrammarParser, {midi, logger, unfoldRepeats = false, baking = false, includeFolders}: {
+	midi?: MIDI.MidiData,
+	logger?: LogRecorder,
+	unfoldRepeats?: boolean,
+	includeFolders?: string[],
+	baking?: boolean,
+} = {}): Promise<{
+	bakingImages?: Readable[],
+	score: ScoreJSON | IncompleteScoreJSON,
+}> => {
+	const t0 = Date.now();
+
+	let lilyDocument = null;
+	let unfoldSource = null;
+
+	if (unfoldRepeats) {
+		lilyDocument = new LilyDocument(lilyParser.parse(source));
+		lilyDocument.interpret();
+		if (lilyDocument.containsRepeat()) {
+			lilyDocument.unfoldRepeats();
+			unfoldSource = lilyDocument.toString();
+
+			// keep 2 version lilypond source note href uniform
+			source = replaceSourceToken(unfoldSource, "\\unfoldRepeats");
+		}
+	}
+
+	const foldData = await makeSheetNotation(source, lilyParser, {logger, lilyDocument, withNotation: !midi && !unfoldSource, includeFolders, baking});
+	const {meta, doc, hashTable, bakingImages} = foldData;
+
+	lilyDocument = lilyDocument || foldData.lilyDocument;
+	//let sheetNotation = foldData.sheetNotation;
+
+	const matchingMidi = midi || foldData.midi;
+
+	if (unfoldSource) {
+		const unfoldData = await makeSheetNotation(unfoldSource, lilyParser, {logger, lilyDocument, withNotation: !midi, includeFolders});
+
+		midi = midi || unfoldData.midi;
+		//sheetNotation = unfoldData.sheetNotation;
+	}
+
+	midi = midi || foldData.midi;
+	const lilyNotation = lilyDocument.interpret().getNotation();
+
+	if (!midi || !lilyNotation) {
+		if (!midi)
+			console.warn("Neither lilypond or external arguments did not offer MIDI data, score maker finished incompletely.");
+
+		if (!lilyNotation)
+			console.warn("sheetNotation parsing failed, score maker finished incompletely.");
+
+		return {
+			score: {
+				version: npmPackage.version,
+				meta,
+				doc,
+				midi,
+				hashTable,
+			},
+		};
+	}
+
+	const t5 = Date.now();
+
+	const matcher = await LilyNotation.matchWithMIDI(lilyNotation, matchingMidi);
+
+	logger.append("scoreMaker.profile.matching", {cost: Date.now() - t5});
+
+	if (logger && logger.enabled) {
+		const cis = new Set(Array(matcher.criterion.notes.length).keys());
+		matcher.path.forEach(ci => cis.delete(ci));
+
+		const omitC = cis.size;
+		const omitS = matcher.path.filter(ci => ci < 0).length;
+
+		const coverage = ((matcher.criterion.notes.length - omitC) / matcher.criterion.notes.length)
+			* ((matcher.sample.notes.length - omitS) / matcher.sample.notes.length);
+
+		logger.append("makeScore.match", {coverage, omitC, omitS, path: matcher.path});
+	}
+
+	const midiNotation = matcher.sample;
+
+	const matchedIds: Set<string> = new Set();
+	midiNotation.notes.forEach(note => note.ids && note.ids.forEach(id => matchedIds.add(id)));
+
+	doc.updateMatchedTokens(matchedIds);
+
+	if (baking)
+		doc.pruneForBakingMode();
+
+	const pitchContextGroup = PitchContextTable.createPitchContextGroup(
+		lilyNotation.pitchContextGroup.map(table => table.items.map(item => item.context)), midiNotation);
+
+	const noteLinkings = midiNotation.notes.map(note => _.pick(note, ["ids", "staffTrack", "contextIndex"]) as NoteLinking);
+
+	logger.append("scoreMaker.profile.full", {cost: Date.now() - t0});
+
+	return {
+		bakingImages,
+		score: {
+			version: npmPackage.version,
+			meta,
+			doc,
+			midi,
+			hashTable: !baking ? hashTable : null,
+			noteLinkings,
+			pitchContextGroup,
+		},
+	};
+};
+
+
+void makeScoreV1;
+void makeScoreV2;
+void makeScoreV3;
+const makeScore = makeScoreV4;
+
+
+const makeMIDI = async (source: string, lilyParser: GrammarParser, {unfoldRepeats = false, fixNestedRepeat = false, includeFolders = undefined} = {}): Promise<MIDI.MidiData> => {
+	const lilyDocument = new LilyDocument(lilyParser.parse(source));
+
+	if (fixNestedRepeat)
+		lilyDocument.fixNestedRepeat();
+
+	if (unfoldRepeats)
+		lilyDocument.unfoldRepeats();
+
+	const score = lilyDocument.root.getBlock("score");
+	if (score) {
+		// remove layout block to save time
+		score.body = score.body.filter(term => !(term instanceof LilyTerms.Block && term.head === "\\layout"));
+
+		// remove invalid tempo
+		const midi: any = score.body.find(term => term instanceof LilyTerms.Block && term.head === "\\midi");
+		if (midi)
+			midi.body = midi.body.filter(term => !(term instanceof LilyTerms.Tempo && term.beatsPerMinute > 200));
+	}
+
+	const markupSource = lilyDocument.toString();
+	//console.log("markupSource:", markupSource);
+
+	return new Promise((resolve, reject) => engraveSvg(markupSource, {
+		includeFolders,
+		onMidiRead: resolve,
+	}).catch(reject));
+};
+
+
+const makeArticulatedMIDI = async (source: string, lilyParser: GrammarParser, {ignoreRepeats = true, includeFolders = undefined} = {}): Promise<MIDI.MidiData> => {
+	const lilyDocument = new LilyDocument(lilyParser.parse(source));
+
+	if (ignoreRepeats)
+		lilyDocument.removeRepeats();
+
+	lilyDocument.articulateMIDIOutput();
+
+	// remove layout block to save time
+	lilyDocument.root.sections = lilyDocument.root.sections.filter(section => !(section instanceof Block)
+		|| !(section.head === "\\score")
+		|| section.isMIDIDedicated);
+
+	const markupSource = lilyDocument.toString();
+	//console.log("markupSource:", markupSource);
+
+	return new Promise((resolve, reject) => engraveSvg(markupSource, {
+		includeFolders,
+		onMidiRead: resolve,
+	}).catch(reject));
+};
+
+
+
+export {
+	markupLily,
+	xmlBufferToLy,
+	makeScore,
+	makeMIDI,
+	makeArticulatedMIDI,
+};

backend/statStorage.ts

@@ -0,0 +1,34 @@
+
+import fs from "fs";
+import path from "path";
+import YAML from "yaml";
+
+import asyncCall from "../inc/asyncCall";
+
+
+
+const exists = async (path: string) => new Promise(resolve => fs.access(path, err => resolve(!err)));
+
+
+const appendData = async (filePath: string, data: object) => {
+	const dir = path.resolve(filePath, "..");
+	const filename = path.relative(dir, filePath);
+	const statPath = path.resolve(dir, ".lotus_stat.yaml");
+
+	let stat = {};
+	if (await exists(statPath)) {
+		const buffer = await asyncCall(fs.readFile, statPath);
+		stat = YAML.parse(buffer.toString()) || stat;
+	}
+
+	stat[filename] = stat[filename] || {};
+	Object.assign(stat[filename], data);
+
+	await asyncCall(fs.writeFile, statPath, YAML.stringify(stat));
+};
+
+
+
+export {
+	appendData,
+};

backend/walkDir.ts

@@ -0,0 +1,35 @@
+
+import fs from "fs";
+import path from "path";
+
+
+
+const walkDir = (dir, pattern, {recursive = false} = {}) => {
+	const list = fs.readdirSync(dir);
+	//console.log("files:", files);
+
+	const subdirs = [];
+
+	const files = list.map(filename => {
+		const file = path.resolve(dir, filename);
+		const stat = fs.statSync(file);
+
+		if (stat.isDirectory())
+			subdirs.push(file);
+
+		return {file, filename, stat};
+	}).filter(({filename, stat}) => !stat.isDirectory() && (!pattern || pattern.test(filename)))
+		.map(({file}) => file);
+
+	if (recursive) {
+		subdirs.forEach(subdir => {
+			files.push(...walkDir(subdir, pattern, {recursive}));
+		});
+	}
+
+	return files;
+};
+
+
+
+export default walkDir;

backend/xmlTools.ts

@@ -0,0 +1,214 @@
+
+import {DOMParser, XMLSerializer} from "xmldom";
+
+import * as domUtils from "../inc/domUtils";
+
+
+
+const isWordDirection = direction => {
+	const directionTypes = domUtils.childrenWithTag(direction, "direction-type");
+
+	for (const dt of directionTypes) {
+		if (domUtils.hasChildrenWithTag(dt, "words"))
+			return true;
+	}
+
+	return false;
+};
+
+
+const moveWordDirection = measure => {
+	//console.log("measure:", measure);
+	const words = [];
+
+	for (let i = 0; i < measure.childNodes.length; ++i) {
+		const child = measure.childNodes[i];
+		switch (child.tagName) {
+		case "direction":
+			if (isWordDirection(child)) {
+				words.push(child);
+				measure.removeChild(child);
+			}
+
+			break;
+		case "note":
+			const next = measure.childNodes[i + 1];
+			words.forEach(word => {
+				if (next)
+					measure.insertBefore(word, next);
+				else
+					measure.appendChild(word);
+			});
+
+			return;
+		}
+	}
+};
+
+
+const preprocessXml = (xml: string, {
+	removeMeasureImplicit = true,
+	replaceEncoding = true,
+	removeNullDynamics = true,
+	fixHeadMarkup = true,
+	fixBackSlashes = true,
+	roundTempo = true,
+	escapedWordsDoubleQuotation = true,
+	removeTrivialRests = true,
+	removeBadMetronome = true,
+	removeInvalidHarmonies = true,
+	removeAllHarmonies = false,
+	fixChordVoice = true,
+	fixBarlines = true,
+	removeInvalidClef = true,
+} = {}): string => {
+	if (!removeMeasureImplicit && !replaceEncoding && !removeNullDynamics && !fixHeadMarkup && !fixBackSlashes && !roundTempo
+		&& !escapedWordsDoubleQuotation && !removeTrivialRests && !removeBadMetronome && !removeInvalidHarmonies && !removeAllHarmonies
+		&& !fixChordVoice && !fixBarlines)
+		return xml;
+
+	// @ts-ignore
+	const dom = new DOMParser().parseFromString(xml, "text/xml");
+
+	if (replaceEncoding) {
+		const headNode = Array.prototype.find.call(dom.childNodes, node => node.tagName === "xml");
+		if (headNode)
+			headNode.data = headNode.data.replace(/UTF-16/, "UTF-8");
+	}
+
+	const needTraverse = removeMeasureImplicit || removeNullDynamics || fixHeadMarkup || fixBackSlashes || roundTempo
+		|| escapedWordsDoubleQuotation || removeTrivialRests || removeBadMetronome || removeInvalidHarmonies || removeAllHarmonies
+		|| fixChordVoice || fixBarlines;
+	if (needTraverse) {
+		domUtils.traverse(dom, node => {
+			if (removeMeasureImplicit) {
+				if (node.tagName === "measure")
+					node.removeAttribute("implicit");
+			}
+
+			if (removeNullDynamics) {
+				if (node.tagName === "other-dynamics") {
+					const content = node.textContent;
+					if (!/\w/.test(content))
+						node.parentNode.removeChild(node);
+				}
+			}
+
+			if (fixHeadMarkup) {
+				if (node.tagName === "measure") {
+					//console.log("measure:", node);
+					moveWordDirection(node);
+				}
+			}
+
+			if (fixBackSlashes) {
+				if (["words", "credit-words", "text"].includes(node.tagName)) {
+					if (/^\\+/.test(node.textContent) || /\\+$/.test(node.textContent)) {
+						console.debug("replaced invalid text:", node.textContent);
+						node.textContent = node.textContent.replace(/^\\+/, "").replace(/\\+$/, "");
+					}
+				}
+			}
+
+			if (roundTempo) {
+				if (node.tagName === "sound") {
+					const tempo = Number(node.getAttribute("tempo"));
+					if (Number.isFinite(tempo) && Math.floor(tempo) !== tempo)
+						node.setAttribute("tempo", Math.round(tempo).toFixed(0));
+				}
+			}
+
+			if (escapedWordsDoubleQuotation) {
+				if (["words", "credit-words", "text"].includes(node.tagName)) {
+					if (node.textContent && /"/.test(node.textContent))
+						node.textContent = node.textContent.replace(/"/g, "'");
+				}
+			}
+
+			if (removeTrivialRests) {
+				if (node.tagName === "note") {
+					if (domUtils.hasChildrenWithTag(node, "rest") && !domUtils.hasChildrenWithTag(node, "type")) {
+						// append an empty tag: <type></type>
+						const type = dom.createElement("type");
+						node.appendChild(type);
+					}
+				}
+			}
+
+			if (removeBadMetronome) {
+				if (node.tagName === "metronome") {
+					if (!domUtils.hasChildrenWithTag(node, "per-minute")) {
+						console.debug("metronome without 'per-minute' removed:", node.toString());
+						node.parentNode.removeChild(node);
+					}
+				}
+			}
+
+			if (removeInvalidHarmonies || removeAllHarmonies) {
+				if (node.tagName === "harmony") {
+					if (removeAllHarmonies)
+						node.parentNode.removeChild(node);
+					else {
+						let next = node.nextSibling;
+						while (next && !next.tagName)
+							next = next.nextSibling;
+	
+						//console.log("sibling:", next);
+						if (!next || next.tagName !== "note") {
+							node.parentNode.removeChild(node);
+							console.debug("invalid harmony removed:", next && next.tagName);
+						}
+					}
+				}
+			}
+
+			if (fixChordVoice) {
+				if (node.tagName === "note" && domUtils.hasChildrenWithTag(node, "chord") && !domUtils.hasChildrenWithTag(node, "voice")) {
+					//console.log("bad note:", node);
+					const previousNote = domUtils.findPreviousSibling(node, "note");
+					if (previousNote) {
+						const voice = domUtils.childrenWithTag(previousNote, "voice")[0];
+						//console.log("chord voice:", node, voice);
+						if (voice)
+							node.appendChild(voice.cloneNode(true));
+					}
+				}
+			}
+
+			if (fixBarlines) {
+				if (node.tagName === "barline") {
+					if ((node.getAttribute("location") === "right" || domUtils.hasChildrenWithTag(node, "bar-style"))
+						&& domUtils.findNextSibling(node, "backup")) {
+						// move the barline to the end of this measure
+						node.parentNode.removeChild(node);
+						node.parentNode.appendChild(node);
+					}
+				}
+			}
+
+			if(removeInvalidClef) {
+				if (node.tagName === "attributes") {
+					const clef = domUtils.childrenWithTag(node, "clef")[0];
+					if (clef) {
+						const n = Number(clef.getAttribute("number"));
+						if (!domUtils.findPreviousSibling(node, "backup") && n > 1) {
+							node.parentNode.removeChild(node);
+							console.debug("invalid clef removed:", n);
+						}
+					}
+				}
+			}
+		});
+	}
+
+	//console.log("dom:", dom);
+
+	// @ts-ignore
+	return new XMLSerializer().serializeToString(dom);
+};
+
+
+
+export {
+	preprocessXml,
+};

dist/index.html

@@ -0,0 +1 @@
+<!DOCTYPE html><html><head><title>Lotus</title><link href="js/chunk-04395031.dbff2f6b.js" rel="prefetch"><link href="js/chunk-0c4e36c8.95d70738.js" rel="prefetch"><link href="js/chunk-0cbfe13e.73856287.js" rel="prefetch"><link href="js/chunk-117382e0.d47336d3.js" rel="prefetch"><link href="js/chunk-2d0c53c7.d24941b8.js" rel="prefetch"><link href="js/chunk-2d0db258.a4804a7a.js" rel="prefetch"><link href="js/chunk-40965e1a.74707226.js" rel="prefetch"><link href="js/chunk-48b5b2a0.3db5a0aa.js" rel="prefetch"><link href="js/chunk-a06ef50c.1caef24f.js" rel="prefetch"><link href="js/chunk-ae402692.003457bc.js" rel="prefetch"><link href="js/chunk-vendors.20f7f886.js" rel="preload" as="script"><link href="js/index.cbb15892.js" rel="preload" as="script"></head><body><script src="js/chunk-vendors.20f7f886.js"></script><script src="js/index.cbb15892.js"></script></body></html>

dist/js/chunk-0c4e36c8.95d70738.js

@@ -0,0 +1,16 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-0c4e36c8"],{"010e":function(e,t,n){"use strict";n.d(t,"a",(function(){return s}));var a=n("9e5c"),i=n.n(a);const r=new Map;async function s(e){if(!r.get(e)){const t=performance.now(),{default:n}=await e,a=await(await fetch(n)).text(),s=performance.now(),o=new i.a;r.set(e,await new o.Parser(a));const l=performance.now();console.debug("Jison parser loading cost:",s-t,l-s)}return r.get(e)}},"0794":function(e,t,n){e.exports=function(){return new Worker(n.p+"e5c1442134f1e7dfb9dd.worker.js")}},"0e06":function(e,t,n){var a=n("7407");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("b061a5c4",a,!0,{sourceMap:!1,shadowMode:!1})},"13c4":function(e,t,n){var a=n("b437");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("155344be",a,!0,{sourceMap:!1,shadowMode:!1})},"1c08":function(e,t){(function(e){for(var t=/\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source,n=5,a=0;a<n;a++)t=t.replace(/<expr>/g,(function(){return t}));t=t.replace(/<expr>/g,/[^\s\S]/.source);var i=e.languages.lilypond={comment:/%(?:(?!\{).*|\{[\s\S]*?%\})/,"embedded-scheme":{pattern:RegExp(/(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(/<expr>/g,(function(){return t})),"m"),lookbehind:!0,greedy:!0,inside:{scheme:{pattern:/^(#)[\s\S]+$/,lookbehind:!0,alias:"language-scheme",inside:{"embedded-lilypond":{pattern:/#\{[\s\S]*?#\}/,greedy:!0,inside:{punctuation:/^#\{|#\}$/,lilypond:{pattern:/[\s\S]+/,alias:"language-lilypond",inside:null}}},rest:e.languages.scheme}},punctuation:/#/}},string:{pattern:/"(?:[^"\\]|\\.)*"/,greedy:!0},"class-name":{pattern:/(\\new\s+)[\w-]+/,lookbehind:!0},keyword:{pattern:/\\[a-z][-\w]*/i,inside:{punctuation:/^\\/}},operator:/[=|]|<<|>>/,punctuation:{pattern:/(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,lookbehind:!0},number:/\b\d+(?:\/\d+)?\b/};i["embedded-scheme"].inside["scheme"].inside["embedded-lilypond"].inside["lilypond"].inside=i,e.languages.ly=i})(Prism)},2669:function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,".source-editor[data-v-d4e36058]{display:inline-block}.prism-editor-wrapper[data-v-d4e36058]{background-color:#f4f2f0;resize:horizontal;width:50em;height:100%;font-family:monospace;font-size:16px;line-height:19px;overflow:auto}",""]),e.exports=t},3122:function(e,t,n){"use strict";var a=function(){var e=this,t=e._self._c;return t("div",{staticClass:"source-editor",on:{click:e.onClick}},[t("PrismEditor",{attrs:{lineNumbers:!0,highlight:e.highlighter,readonly:e.disabled,tabSize:4},model:{value:e.editText,callback:function(t){e.editText=t},expression:"editText"}})],1)},i=[],r=(n("cabf"),n("13c4"),n("c197")),s=(n("1c08"),n("2b0e"));function o(){return o=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&(e[a]=n[a])}return e},o.apply(this,arguments)}var l=13,u=9,c=8,d=89,p=90,g=77,h=57,f=219,m=222,y=192,v=27,b=100,k=3e3,w="undefined"!==typeof window&&navigator&&/Win/i.test(navigator.platform),x="undefined"!==typeof window&&navigator&&/(Mac|iPhone|iPod|iPad)/i.test(navigator.platform),_=s["a"].extend({props:{lineNumbers:{type:Boolean,default:!1},autoStyleLineNumbers:{type:Boolean,default:!0},readonly:{type:Boolean,default:!1},value:{type:String,default:""},highlight:{type:Function,required:!0},tabSize:{type:Number,default:2},insertSpaces:{type:Boolean,default:!0},ignoreTabKey:{type:Boolean,default:!1},placeholder:{type:String,default:""}},data:function(){return{capture:!0,history:{stack:[],offset:-1},lineNumbersHeight:"20px",codeData:""}},watch:{value:{immediate:!0,handler:function(e){this.codeData=e||""}},content:{immediate:!0,handler:function(){var e=this;this.lineNumbers&&this.$nextTick((function(){e.setLineNumbersHeight()}))}},lineNumbers:function(){var e=this;this.$nextTick((function(){e.styleLineNumbers(),e.setLineNumbersHeight()}))}},computed:{isEmpty:function(){return 0===this.codeData.length},content:function(){var e=this.highlight(this.codeData)+"<br />";return e},lineNumbersCount:function(){var e=this.codeData.split(/\r\n|\n/).length;return e}},mounted:function(){this._recordCurrentState(),this.styleLineNumbers()},methods:{setLineNumbersHeight:function(){this.lineNumbersHeight=getComputedStyle(this.$refs.pre).height},styleLineNumbers:function(){if(this.lineNumbers&&this.autoStyleLineNumbers){var e=this.$refs.pre,t=this.$el.querySelector(".prism-editor__line-numbers"),n=window.getComputedStyle(e);this.$nextTick((function(){var a="border-top-left-radius",i="border-bottom-left-radius";if(t){t.style[a]=n[a],t.style[i]=n[i],e.style[a]="0",e.style[i]="0";var r=["background-color","margin-top","padding-top","font-family","font-size","line-height"];r.forEach((function(e){t.style[e]=n[e]})),t.style["margin-bottom"]="-"+n["padding-top"]}}))}},_recordCurrentState:function(){var e=this.$refs.textarea;if(e){var t=e.value,n=e.selectionStart,a=e.selectionEnd;this._recordChange({value:t,selectionStart:n,selectionEnd:a})}},_getLines:function(e,t){return e.substring(0,t).split("\n")},_applyEdits:function(e){var t=this.$refs.textarea,n=this.history.stack[this.history.offset];n&&t&&(this.history.stack[this.history.offset]=o({},n,{selectionStart:t.selectionStart,selectionEnd:t.selectionEnd})),this._recordChange(e),this._updateInput(e)},_recordChange:function(e,t){void 0===t&&(t=!1);var n=this.history,a=n.stack,i=n.offset;if(a.length&&i>-1){this.history.stack=a.slice(0,i+1);var r=this.history.stack.length;if(r>b){var s=r-b;this.history.stack=a.slice(s,r),this.history.offset=Math.max(this.history.offset-s,0)}}var l=Date.now();if(t){var u=this.history.stack[this.history.offset];if(u&&l-u.timestamp<k){var c,d,p=/[^a-z0-9]([a-z0-9]+)$/i,g=null===(c=this._getLines(u.value,u.selectionStart).pop())||void 0===c?void 0:c.match(p),h=null===(d=this._getLines(e.value,e.selectionStart).pop())||void 0===d?void 0:d.match(p);if(g&&h&&h[1].startsWith(g[1]))return void(this.history.stack[this.history.offset]=o({},e,{timestamp:l}))}}this.history.stack.push(o({},e,{timestamp:l})),this.history.offset++},_updateInput:function(e){var t=this.$refs.textarea;t&&(t.value=e.value,t.selectionStart=e.selectionStart,t.selectionEnd=e.selectionEnd,this.$emit("input",e.value))},handleChange:function(e){var t=e.target,n=t.value,a=t.selectionStart,i=t.selectionEnd;this._recordChange({value:n,selectionStart:a,selectionEnd:i},!0),this.$emit("input",n)},_undoEdit:function(){var e=this.history,t=e.stack,n=e.offset,a=t[n-1];a&&(this._updateInput(a),this.history.offset=Math.max(n-1,0))},_redoEdit:function(){var e=this.history,t=e.stack,n=e.offset,a=t[n+1];a&&(this._updateInput(a),this.history.offset=Math.min(n+1,t.length-1))},handleKeyDown:function(e){var t=this.tabSize,n=this.insertSpaces,a=this.ignoreTabKey;if(!this.$listeners.keydown||(this.$emit("keydown",e),!e.defaultPrevented)){e.keyCode===v&&(e.target.blur(),this.$emit("blur",e));var i=e.target,r=i.value,s=i.selectionStart,o=i.selectionEnd,b=(n?" ":"\t").repeat(t);if(e.keyCode===u&&!a&&this.capture)if(e.preventDefault(),e.shiftKey){var k=this._getLines(r,s),_=k.length-1,E=this._getLines(r,o).length-1,F=r.split("\n").map((function(e,t){return t>=_&&t<=E&&e.startsWith(b)?e.substring(b.length):e})).join("\n");if(r!==F){var A=k[_];this._applyEdits({value:F,selectionStart:A.startsWith(b)?s-b.length:s,selectionEnd:o-(r.length-F.length)})}}else if(s!==o){var S=this._getLines(r,s),$=S.length-1,C=this._getLines(r,o).length-1,z=S[$];this._applyEdits({value:r.split("\n").map((function(e,t){return t>=$&&t<=C?b+e:e})).join("\n"),selectionStart:/\S/.test(z)?s+b.length:s,selectionEnd:o+b.length*(C-$+1)})}else{var M=s+b.length;this._applyEdits({value:r.substring(0,s)+b+r.substring(o),selectionStart:M,selectionEnd:M})}else if(e.keyCode===c){var L=s!==o,T=r.substring(0,s);if(T.endsWith(b)&&!L){e.preventDefault();var j=s-b.length;this._applyEdits({value:r.substring(0,s-b.length)+r.substring(o),selectionStart:j,selectionEnd:j})}}else if(e.keyCode===l){if(s===o){var P=this._getLines(r,s).pop(),N=null===P||void 0===P?void 0:P.match(/^\s+/);if(N&&N[0]){e.preventDefault();var O="\n"+N[0],D=s+O.length;this._applyEdits({value:r.substring(0,s)+O+r.substring(o),selectionStart:D,selectionEnd:D})}}}else if(e.keyCode===h||e.keyCode===f||e.keyCode===m||e.keyCode===y){var R;e.keyCode===h&&e.shiftKey?R=["(",")"]:e.keyCode===f?R=e.shiftKey?["{","}"]:["[","]"]:e.keyCode===m?R=e.shiftKey?['"','"']:["'","'"]:e.keyCode!==y||e.shiftKey||(R=["`","`"]),s!==o&&R&&(e.preventDefault(),this._applyEdits({value:r.substring(0,s)+R[0]+r.substring(s,o)+R[1]+r.substring(o),selectionStart:s,selectionEnd:o+2}))}else!(x?e.metaKey&&e.keyCode===p:e.ctrlKey&&e.keyCode===p)||e.shiftKey||e.altKey?(x?e.metaKey&&e.keyCode===p&&e.shiftKey:w?e.ctrlKey&&e.keyCode===d:e.ctrlKey&&e.keyCode===p&&e.shiftKey)&&!e.altKey?(e.preventDefault(),this._redoEdit()):e.keyCode!==g||!e.ctrlKey||x&&!e.shiftKey||(e.preventDefault(),this.capture=!this.capture):(e.preventDefault(),this._undoEdit())}}},render:function(e){var t=this,n=e("div",{attrs:{class:"prism-editor__line-width-calc",style:"height: 0px; visibility: hidden; pointer-events: none;"}},"999"),a=e("div",{staticClass:"prism-editor__line-numbers",style:{"min-height":this.lineNumbersHeight},attrs:{"aria-hidden":"true"}},[n,Array.from(Array(this.lineNumbersCount).keys()).map((function(t,n){return e("div",{attrs:{class:"prism-editor__line-number token comment"}},""+ ++n)}))]),i=e("textarea",{ref:"textarea",on:{input:this.handleChange,keydown:this.handleKeyDown,click:function(e){t.$emit("click",e)},keyup:function(e){t.$emit("keyup",e)},focus:function(e){t.$emit("focus",e)},blur:function(e){t.$emit("blur",e)}},staticClass:"prism-editor__textarea",class:{"prism-editor__textarea--empty":this.isEmpty},attrs:{spellCheck:"false",autocapitalize:"off",autocomplete:"off",autocorrect:"off","data-gramm":"false",placeholder:this.placeholder,"data-testid":"textarea",readonly:this.readonly},domProps:{value:this.codeData}}),r=e("pre",{ref:"pre",staticClass:"prism-editor__editor",attrs:{"data-testid":"preview"},domProps:{innerHTML:this.content}}),s=e("div",{staticClass:"prism-editor__container"},[i,r]);return e("div",{staticClass:"prism-editor-wrapper"},[this.lineNumbers&&a,s])}}),E={name:"source-editor",props:{source:String,disabled:Boolean},components:{PrismEditor:_},data(){return{editText:this.source}},methods:{highlighter(e){return Object(r["highlight"])(e,r["languages"].lilypond)},onClick(){document.activeElement&&"TEXTAREA"===document.activeElement.tagName||this.$el.querySelector("textarea").focus()}},watch:{editText(e){this.source!==e&&this.$emit("update:source",e)},source(e){this.editText=e}}},F=E,A=(n("afdd"),n("b2c1"),n("2877")),S=Object(A["a"])(F,a,i,!1,null,"d4e36058",null);t["a"]=S.exports},"3d15":function(e,t,n){"use strict";n.r(t),n.d(t,"createEndpoint",(function(){return i})),n.d(t,"expose",(function(){return g})),n.d(t,"finalizer",(function(){return s})),n.d(t,"proxy",(function(){return $})),n.d(t,"proxyMarker",(function(){return a})),n.d(t,"releaseProxy",(function(){return r})),n.d(t,"transfer",(function(){return S})),n.d(t,"transferHandlers",(function(){return d})),n.d(t,"windowEndpoint",(function(){return C})),n.d(t,"wrap",(function(){return m}));
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const a=Symbol("Comlink.proxy"),i=Symbol("Comlink.endpoint"),r=Symbol("Comlink.releaseProxy"),s=Symbol("Comlink.finalizer"),o=Symbol("Comlink.thrown"),l=e=>"object"===typeof e&&null!==e||"function"===typeof e,u={canHandle:e=>l(e)&&e[a],serialize(e){const{port1:t,port2:n}=new MessageChannel;return g(e,t),[n,[n]]},deserialize(e){return e.start(),m(e)}},c={canHandle:e=>l(e)&&o in e,serialize({value:e}){let t;return t=e instanceof Error?{isError:!0,value:{message:e.message,name:e.name,stack:e.stack}}:{isError:!1,value:e},[t,[]]},deserialize(e){if(e.isError)throw Object.assign(new Error(e.value.message),e.value);throw e.value}},d=new Map([["proxy",u],["throw",c]]);function p(e,t){for(const n of e){if(t===n||"*"===n)return!0;if(n instanceof RegExp&&n.test(t))return!0}return!1}function g(e,t=globalThis,n=["*"]){t.addEventListener("message",(function a(i){if(!i||!i.data)return;if(!p(n,i.origin))return void console.warn(`Invalid origin '${i.origin}' for comlink proxy`);const{id:r,type:l,path:u}=Object.assign({path:[]},i.data),c=(i.data.argumentList||[]).map(M);let d;try{const t=u.slice(0,-1).reduce((e,t)=>e[t],e),n=u.reduce((e,t)=>e[t],e);switch(l){case"GET":d=n;break;case"SET":t[u.slice(-1)[0]]=M(i.data.value),d=!0;break;case"APPLY":d=n.apply(t,c);break;case"CONSTRUCT":{const e=new n(...c);d=$(e)}break;case"ENDPOINT":{const{port1:t,port2:n}=new MessageChannel;g(e,n),d=S(t,[t])}break;case"RELEASE":d=void 0;break;default:return}}catch(h){d={value:h,[o]:0}}Promise.resolve(d).catch(e=>({value:e,[o]:0})).then(n=>{const[i,o]=z(n);t.postMessage(Object.assign(Object.assign({},i),{id:r}),o),"RELEASE"===l&&(t.removeEventListener("message",a),f(t),s in e&&"function"===typeof e[s]&&e[s]())}).catch(e=>{const[n,a]=z({value:new TypeError("Unserializable return value"),[o]:0});t.postMessage(Object.assign(Object.assign({},n),{id:r}),a)})})),t.start&&t.start()}function h(e){return"MessagePort"===e.constructor.name}function f(e){h(e)&&e.close()}function m(e,t){const n=new Map;return e.addEventListener("message",(function(e){const{data:t}=e;if(!t||!t.id)return;const a=n.get(t.id);if(a)try{a(t)}finally{n.delete(t.id)}})),_(e,n,[],t)}function y(e){if(e)throw new Error("Proxy has been released and is not useable")}function v(e){return L(e,new Map,{type:"RELEASE"}).then(()=>{f(e)})}const b=new WeakMap,k="FinalizationRegistry"in globalThis&&new FinalizationRegistry(e=>{const t=(b.get(e)||0)-1;b.set(e,t),0===t&&v(e)});function w(e,t){const n=(b.get(t)||0)+1;b.set(t,n),k&&k.register(e,t,e)}function x(e){k&&k.unregister(e)}function _(e,t,n=[],a=function(){}){let s=!1;const o=new Proxy(a,{get(a,i){if(y(s),i===r)return()=>{x(o),v(e),t.clear(),s=!0};if("then"===i){if(0===n.length)return{then:()=>o};const a=L(e,t,{type:"GET",path:n.map(e=>e.toString())}).then(M);return a.then.bind(a)}return _(e,t,[...n,i])},set(a,i,r){y(s);const[o,l]=z(r);return L(e,t,{type:"SET",path:[...n,i].map(e=>e.toString()),value:o},l).then(M)},apply(a,r,o){y(s);const l=n[n.length-1];if(l===i)return L(e,t,{type:"ENDPOINT"}).then(M);if("bind"===l)return _(e,t,n.slice(0,-1));const[u,c]=F(o);return L(e,t,{type:"APPLY",path:n.map(e=>e.toString()),argumentList:u},c).then(M)},construct(a,i){y(s);const[r,o]=F(i);return L(e,t,{type:"CONSTRUCT",path:n.map(e=>e.toString()),argumentList:r},o).then(M)}});return w(o,e),o}function E(e){return Array.prototype.concat.apply([],e)}function F(e){const t=e.map(z);return[t.map(e=>e[0]),E(t.map(e=>e[1]))]}const A=new WeakMap;function S(e,t){return A.set(e,t),e}function $(e){return Object.assign(e,{[a]:!0})}function C(e,t=globalThis,n="*"){return{postMessage:(t,a)=>e.postMessage(t,n,a),addEventListener:t.addEventListener.bind(t),removeEventListener:t.removeEventListener.bind(t)}}function z(e){for(const[t,n]of d)if(n.canHandle(e)){const[a,i]=n.serialize(e);return[{type:"HANDLER",name:t,value:a},i]}return[{type:"RAW",value:e},A.get(e)||[]]}function M(e){switch(e.type){case"HANDLER":return d.get(e.name).deserialize(e.value);case"RAW":return e.value}}function L(e,t,n,a){return new Promise(i=>{const r=T();t.set(r,i),e.start&&e.start(),e.postMessage(Object.assign({id:r},n),a)})}function T(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}},"3f8a":function(e,t,n){"use strict";n("9e2c")},"488d":function(e,t,n){"use strict";var a=function(){var e=this;e._self._c;return e._m(0)},i=[function(){var e=this,t=e._self._c;return t("div",{staticClass:"loading-dots"},[t("div",{staticClass:"ellipsis"},[t("div"),t("div"),t("div"),t("div")])])}],r={name:"loading-dots"},s=r,o=(n("b214"),n("2877")),l=Object(o["a"])(s,a,i,!1,null,"077207e4",null);t["a"]=l.exports},"563b":function(e,t,n){var a=n("6eaa");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("069f7faa",a,!0,{sourceMap:!1,shadowMode:!1})},"6eaa":function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,".loading-dots[data-v-077207e4]{position:absolute;top:0;left:0;width:100%;height:100%;background-color:hsla(0,0%,100%,.26666666666666666)}.ellipsis[data-v-077207e4]{display:inline-block;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);width:80px;height:80px}.ellipsis div[data-v-077207e4]{position:absolute;top:33px;width:13px;height:13px;border-radius:50%;background:hsla(0,0%,40%,.8);animation-timing-function:cubic-bezier(0,1,1,0)}.ellipsis div[data-v-077207e4]:first-child{left:8px;animation:ellipsis1-077207e4 .6s infinite}.ellipsis div[data-v-077207e4]:nth-child(2){left:8px;animation:ellipsis2-077207e4 .6s infinite}.ellipsis div[data-v-077207e4]:nth-child(3){left:32px;animation:ellipsis2-077207e4 .6s infinite}.ellipsis div[data-v-077207e4]:nth-child(4){left:56px;animation:ellipsis3-077207e4 .6s infinite}@keyframes ellipsis1-077207e4{0%{transform:scale(0)}to{transform:scale(1)}}@keyframes ellipsis3-077207e4{0%{transform:scale(1)}to{transform:scale(0)}}@keyframes ellipsis2-077207e4{0%{transform:translate(0)}to{transform:translate(24px)}}",""]),e.exports=t},7407:function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,".prism-editor-wrapper pre,.prism-editor-wrapper textarea{white-space:pre!important}.prism-editor-wrapper textarea:focus{outline:0}.prism-editor__line-numbers{-webkit-user-select:none;-moz-user-select:none;user-select:none}.prism-editor__container{overflow:unset!important;width:1000%!important}",""]),e.exports=t},8661:function(e,t,n){var a=n("2669");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("769f8f1d",a,!0,{sourceMap:!1,shadowMode:!1})},"919f":function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,".sheet[data-v-682d3448]{white-space:nowrap}.page[data-v-682d3448],.sheet[data-v-682d3448]{display:inline-block}.page[data-v-682d3448]{margin:0 1em;background-color:#f6faff}",""]),e.exports=t},"94c1":function(e,t,n){"use strict";var a=function(){var e=this,t=e._self._c;return t("div",{staticClass:"sheet"},e._l(e.documents,(function(n,a){return t("span",{key:a,staticClass:"page",domProps:{innerHTML:e._s(n)}})})),0)},i=[],r={name:"sheet-simple",props:{documents:Array},mounted(){this.bindLinks()},updated(){this.$nextTick(()=>this.bindLinks())},methods:{bindLinks(){const e=this.$el.querySelectorAll("a");for(const t of e)t.onclick=e=>this.$emit("linkClick",e,t.href.baseVal)}}},s=r,o=(n("3f8a"),n("2877")),l=Object(o["a"])(s,a,i,!1,null,"682d3448",null);t["a"]=l.exports},"9e2c":function(e,t,n){var a=n("919f");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("3136d68c",a,!0,{sourceMap:!1,shadowMode:!1})},"9e5c":function(e,t,n){var a,i=n("3d15").wrap,r=n("0794");e.exports=function e(){return this instanceof e?i(r()):a||(a=i(r()))}},ac16:function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,".prism-editor-wrapper{width:100%;height:100%;display:flex;align-items:flex-start;overflow:auto;-o-tab-size:1.5em;tab-size:1.5em;-moz-tab-size:1.5em}@media (-ms-high-contrast:active),(-ms-high-contrast:none){.prism-editor-wrapper .prism-editor__textarea{color:transparent!important}.prism-editor-wrapper .prism-editor__textarea::-moz-selection{background-color:#accef7!important;color:transparent!important}.prism-editor-wrapper .prism-editor__textarea::selection{background-color:#accef7!important;color:transparent!important}}.prism-editor-wrapper .prism-editor__container{position:relative;text-align:left;box-sizing:border-box;padding:0;overflow:hidden;width:100%}.prism-editor-wrapper .prism-editor__line-numbers{height:100%;overflow:hidden;flex-shrink:0;padding-top:4px;margin-top:0;margin-right:10px}.prism-editor-wrapper .prism-editor__line-number{text-align:right;white-space:nowrap}.prism-editor-wrapper .prism-editor__textarea{position:absolute;top:0;left:0;height:100%;width:100%;resize:none;color:inherit;overflow:hidden;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;-webkit-text-fill-color:transparent}.prism-editor-wrapper .prism-editor__editor,.prism-editor-wrapper .prism-editor__textarea{margin:0;border:0;background:none;box-sizing:inherit;display:inherit;font-family:inherit;font-size:inherit;font-style:inherit;font-variant-ligatures:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;-moz-tab-size:inherit;-o-tab-size:inherit;tab-size:inherit;text-indent:inherit;text-rendering:inherit;text-transform:inherit;white-space:pre-wrap;word-wrap:keep-all;overflow-wrap:break-word;padding:0}.prism-editor-wrapper .prism-editor__textarea--empty{-webkit-text-fill-color:inherit!important}.prism-editor-wrapper .prism-editor__editor{position:relative;pointer-events:none}",""]),e.exports=t},afdd:function(e,t,n){"use strict";n("8661")},b214:function(e,t,n){"use strict";n("563b")},b2c1:function(e,t,n){"use strict";n("0e06")},b437:function(e,t,n){var a=n("24fb");t=a(!1),t.push([e.i,"code[class*=language-],pre[class*=language-]{color:#657b83;font-family:Consolas,Monaco,Andale Mono,Ubuntu Mono,monospace;font-size:1em;text-align:left;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.5;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;hyphens:none}code[class*=language-]::-moz-selection,code[class*=language-] ::-moz-selection,pre[class*=language-]::-moz-selection,pre[class*=language-] ::-moz-selection{background:#073642}code[class*=language-]::selection,code[class*=language-] ::selection,pre[class*=language-]::selection,pre[class*=language-] ::selection{background:#073642}pre[class*=language-]{padding:1em;margin:.5em 0;overflow:auto;border-radius:.3em}:not(pre)>code[class*=language-],pre[class*=language-]{background-color:#fdf6e3}:not(pre)>code[class*=language-]{padding:.1em;border-radius:.3em}.token.cdata,.token.comment,.token.doctype,.token.prolog{color:#93a1a1}.token.punctuation{color:#586e75}.token.namespace{opacity:.7}.token.boolean,.token.constant,.token.deleted,.token.number,.token.property,.token.symbol,.token.tag{color:#268bd2}.token.attr-name,.token.builtin,.token.char,.token.inserted,.token.selector,.token.string,.token.url{color:#2aa198}.token.entity{color:#657b83;background:#eee8d5}.token.atrule,.token.attr-value,.token.keyword{color:#859900}.token.class-name,.token.function{color:#b58900}.token.important,.token.regex,.token.variable{color:#cb4b16}.token.bold,.token.important{font-weight:700}.token.italic{font-style:italic}.token.entity{cursor:help}",""]),e.exports=t},c197:function(e,t,n){(function(t){var n="undefined"!==typeof window?window:"undefined"!==typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?self:{},a=function(e){var t=/(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,n=0,a={},i={manual:e.Prism&&e.Prism.manual,disableWorkerMessageHandler:e.Prism&&e.Prism.disableWorkerMessageHandler,util:{encode:function e(t){return t instanceof r?new r(t.type,e(t.content),t.alias):Array.isArray(t)?t.map(e):t.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/\u00a0/g," ")},type:function(e){return Object.prototype.toString.call(e).slice(8,-1)},objId:function(e){return e["__id"]||Object.defineProperty(e,"__id",{value:++n}),e["__id"]},clone:function e(t,n){var a,r;switch(n=n||{},i.util.type(t)){case"Object":if(r=i.util.objId(t),n[r])return n[r];for(var s in a={},n[r]=a,t)t.hasOwnProperty(s)&&(a[s]=e(t[s],n));return a;case"Array":return r=i.util.objId(t),n[r]?n[r]:(a=[],n[r]=a,t.forEach((function(t,i){a[i]=e(t,n)})),a);default:return t}},getLanguage:function(e){while(e){var n=t.exec(e.className);if(n)return n[1].toLowerCase();e=e.parentElement}return"none"},setLanguage:function(e,n){e.className=e.className.replace(RegExp(t,"gi"),""),e.classList.add("language-"+n)},currentScript:function(){if("undefined"===typeof document)return null;if("currentScript"in document)return document.currentScript;try{throw new Error}catch(a){var e=(/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(a.stack)||[])[1];if(e){var t=document.getElementsByTagName("script");for(var n in t)if(t[n].src==e)return t[n]}return null}},isActive:function(e,t,n){var a="no-"+t;while(e){var i=e.classList;if(i.contains(t))return!0;if(i.contains(a))return!1;e=e.parentElement}return!!n}},languages:{plain:a,plaintext:a,text:a,txt:a,extend:function(e,t){var n=i.util.clone(i.languages[e]);for(var a in t)n[a]=t[a];return n},insertBefore:function(e,t,n,a){a=a||i.languages;var r=a[e],s={};for(var o in r)if(r.hasOwnProperty(o)){if(o==t)for(var l in n)n.hasOwnProperty(l)&&(s[l]=n[l]);n.hasOwnProperty(o)||(s[o]=r[o])}var u=a[e];return a[e]=s,i.languages.DFS(i.languages,(function(t,n){n===u&&t!=e&&(this[t]=s)})),s},DFS:function e(t,n,a,r){r=r||{};var s=i.util.objId;for(var o in t)if(t.hasOwnProperty(o)){n.call(t,o,t[o],a||o);var l=t[o],u=i.util.type(l);"Object"!==u||r[s(l)]?"Array"!==u||r[s(l)]||(r[s(l)]=!0,e(l,n,o,r)):(r[s(l)]=!0,e(l,n,null,r))}}},plugins:{},highlightAll:function(e,t){i.highlightAllUnder(document,e,t)},highlightAllUnder:function(e,t,n){var a={callback:n,container:e,selector:'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'};i.hooks.run("before-highlightall",a),a.elements=Array.prototype.slice.apply(a.container.querySelectorAll(a.selector)),i.hooks.run("before-all-elements-highlight",a);for(var r,s=0;r=a.elements[s++];)i.highlightElement(r,!0===t,a.callback)},highlightElement:function(t,n,a){var r=i.util.getLanguage(t),s=i.languages[r];i.util.setLanguage(t,r);var o=t.parentElement;o&&"pre"===o.nodeName.toLowerCase()&&i.util.setLanguage(o,r);var l=t.textContent,u={element:t,language:r,grammar:s,code:l};function c(e){u.highlightedCode=e,i.hooks.run("before-insert",u),u.element.innerHTML=u.highlightedCode,i.hooks.run("after-highlight",u),i.hooks.run("complete",u),a&&a.call(u.element)}if(i.hooks.run("before-sanity-check",u),o=u.element.parentElement,o&&"pre"===o.nodeName.toLowerCase()&&!o.hasAttribute("tabindex")&&o.setAttribute("tabindex","0"),!u.code)return i.hooks.run("complete",u),void(a&&a.call(u.element));if(i.hooks.run("before-highlight",u),u.grammar)if(n&&e.Worker){var d=new Worker(i.filename);d.onmessage=function(e){c(e.data)},d.postMessage(JSON.stringify({language:u.language,code:u.code,immediateClose:!0}))}else c(i.highlight(u.code,u.grammar,u.language));else c(i.util.encode(u.code))},highlight:function(e,t,n){var a={code:e,grammar:t,language:n};if(i.hooks.run("before-tokenize",a),!a.grammar)throw new Error('The language "'+a.language+'" has no grammar.');return a.tokens=i.tokenize(a.code,a.grammar),i.hooks.run("after-tokenize",a),r.stringify(i.util.encode(a.tokens),a.language)},tokenize:function(e,t){var n=t.rest;if(n){for(var a in n)t[a]=n[a];delete t.rest}var i=new l;return u(i,i.head,e),o(e,i,t,i.head,0),d(i)},hooks:{all:{},add:function(e,t){var n=i.hooks.all;n[e]=n[e]||[],n[e].push(t)},run:function(e,t){var n=i.hooks.all[e];if(n&&n.length)for(var a,r=0;a=n[r++];)a(t)}},Token:r};function r(e,t,n,a){this.type=e,this.content=t,this.alias=n,this.length=0|(a||"").length}function s(e,t,n,a){e.lastIndex=t;var i=e.exec(n);if(i&&a&&i[1]){var r=i[1].length;i.index+=r,i[0]=i[0].slice(r)}return i}function o(e,t,n,a,l,d){for(var p in n)if(n.hasOwnProperty(p)&&n[p]){var g=n[p];g=Array.isArray(g)?g:[g];for(var h=0;h<g.length;++h){if(d&&d.cause==p+","+h)return;var f=g[h],m=f.inside,y=!!f.lookbehind,v=!!f.greedy,b=f.alias;if(v&&!f.pattern.global){var k=f.pattern.toString().match(/[imsuy]*$/)[0];f.pattern=RegExp(f.pattern.source,k+"g")}for(var w=f.pattern||f,x=a.next,_=l;x!==t.tail;_+=x.value.length,x=x.next){if(d&&_>=d.reach)break;var E=x.value;if(t.length>e.length)return;if(!(E instanceof r)){var F,A=1;if(v){if(F=s(w,_,e,y),!F||F.index>=e.length)break;var S=F.index,$=F.index+F[0].length,C=_;C+=x.value.length;while(S>=C)x=x.next,C+=x.value.length;if(C-=x.value.length,_=C,x.value instanceof r)continue;for(var z=x;z!==t.tail&&(C<$||"string"===typeof z.value);z=z.next)A++,C+=z.value.length;A--,E=e.slice(_,C),F.index-=_}else if(F=s(w,0,E,y),!F)continue;S=F.index;var M=F[0],L=E.slice(0,S),T=E.slice(S+M.length),j=_+E.length;d&&j>d.reach&&(d.reach=j);var P=x.prev;L&&(P=u(t,P,L),_+=L.length),c(t,P,A);var N=new r(p,m?i.tokenize(M,m):M,b,M);if(x=u(t,P,N),T&&u(t,x,T),A>1){var O={cause:p+","+h,reach:j};o(e,t,n,x.prev,_,O),d&&O.reach>d.reach&&(d.reach=O.reach)}}}}}}function l(){var e={value:null,prev:null,next:null},t={value:null,prev:e,next:null};e.next=t,this.head=e,this.tail=t,this.length=0}function u(e,t,n){var a=t.next,i={value:n,prev:t,next:a};return t.next=i,a.prev=i,e.length++,i}function c(e,t,n){for(var a=t.next,i=0;i<n&&a!==e.tail;i++)a=a.next;t.next=a,a.prev=t,e.length-=i}function d(e){var t=[],n=e.head.next;while(n!==e.tail)t.push(n.value),n=n.next;return t}if(e.Prism=i,r.stringify=function e(t,n){if("string"==typeof t)return t;if(Array.isArray(t)){var a="";return t.forEach((function(t){a+=e(t,n)})),a}var r={type:t.type,content:e(t.content,n),tag:"span",classes:["token",t.type],attributes:{},language:n},s=t.alias;s&&(Array.isArray(s)?Array.prototype.push.apply(r.classes,s):r.classes.push(s)),i.hooks.run("wrap",r);var o="";for(var l in r.attributes)o+=" "+l+'="'+(r.attributes[l]||"").replace(/"/g,"&quot;")+'"';return"<"+r.tag+' class="'+r.classes.join(" ")+'"'+o+">"+r.content+"</"+r.tag+">"},!e.document)return e.addEventListener?(i.disableWorkerMessageHandler||e.addEventListener("message",(function(t){var n=JSON.parse(t.data),a=n.language,r=n.code,s=n.immediateClose;e.postMessage(i.highlight(r,i.languages[a],a)),s&&e.close()}),!1),i):i;var p=i.util.currentScript();function g(){i.manual||i.highlightAll()}if(p&&(i.filename=p.src,p.hasAttribute("data-manual")&&(i.manual=!0)),!i.manual){var h=document.readyState;"loading"===h||"interactive"===h&&p&&p.defer?document.addEventListener("DOMContentLoaded",g):window.requestAnimationFrame?window.requestAnimationFrame(g):window.setTimeout(g,16)}return i}(n);
+/**
+ * Prism: Lightweight, robust, elegant syntax highlighting
+ *
+ * @license MIT <https://opensource.org/licenses/MIT>
+ * @author Lea Verou <https://lea.verou.me>
+ * @namespace
+ * @public
+ */e.exports&&(e.exports=a),"undefined"!==typeof t&&(t.Prism=a),a.languages.markup={comment:{pattern:/<!--(?:(?!<!--)[\s\S])*?-->/,greedy:!0},prolog:{pattern:/<\?[\s\S]+?\?>/,greedy:!0},doctype:{pattern:/<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,greedy:!0,inside:{"internal-subset":{pattern:/(^[^\[]*\[)[\s\S]+(?=\]>$)/,lookbehind:!0,greedy:!0,inside:null},string:{pattern:/"[^"]*"|'[^']*'/,greedy:!0},punctuation:/^<!|>$|[[\]]/,"doctype-tag":/^DOCTYPE/i,name:/[^\s<>'"]+/}},cdata:{pattern:/<!\[CDATA\[[\s\S]*?\]\]>/i,greedy:!0},tag:{pattern:/<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,greedy:!0,inside:{tag:{pattern:/^<\/?[^\s>\/]+/,inside:{punctuation:/^<\/?/,namespace:/^[^\s>\/:]+:/}},"special-attr":[],"attr-value":{pattern:/=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,inside:{punctuation:[{pattern:/^=/,alias:"attr-equals"},{pattern:/^(\s*)["']|["']$/,lookbehind:!0}]}},punctuation:/\/?>/,"attr-name":{pattern:/[^\s>\/]+/,inside:{namespace:/^[^\s>\/:]+:/}}}},entity:[{pattern:/&[\da-z]{1,8};/i,alias:"named-entity"},/&#x?[\da-f]{1,8};/i]},a.languages.markup["tag"].inside["attr-value"].inside["entity"]=a.languages.markup["entity"],a.languages.markup["doctype"].inside["internal-subset"].inside=a.languages.markup,a.hooks.add("wrap",(function(e){"entity"===e.type&&(e.attributes["title"]=e.content.replace(/&amp;/,"&"))})),Object.defineProperty(a.languages.markup.tag,"addInlined",{value:function(e,t){var n={};n["language-"+t]={pattern:/(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,lookbehind:!0,inside:a.languages[t]},n["cdata"]=/^<!\[CDATA\[|\]\]>$/i;var i={"included-cdata":{pattern:/<!\[CDATA\[[\s\S]*?\]\]>/i,inside:n}};i["language-"+t]={pattern:/[\s\S]+/,inside:a.languages[t]};var r={};r[e]={pattern:RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g,(function(){return e})),"i"),lookbehind:!0,greedy:!0,inside:i},a.languages.insertBefore("markup","cdata",r)}}),Object.defineProperty(a.languages.markup.tag,"addAttribute",{value:function(e,t){a.languages.markup.tag.inside["special-attr"].push({pattern:RegExp(/(^|["'\s])/.source+"(?:"+e+")"+/\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,"i"),lookbehind:!0,inside:{"attr-name":/^[^\s=]+/,"attr-value":{pattern:/=[\s\S]+/,inside:{value:{pattern:/(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,lookbehind:!0,alias:[t,"language-"+t],inside:a.languages[t]},punctuation:[{pattern:/^=/,alias:"attr-equals"},/"|'/]}}}})}}),a.languages.html=a.languages.markup,a.languages.mathml=a.languages.markup,a.languages.svg=a.languages.markup,a.languages.xml=a.languages.extend("markup",{}),a.languages.ssml=a.languages.xml,a.languages.atom=a.languages.xml,a.languages.rss=a.languages.xml,function(e){var t=/(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;e.languages.css={comment:/\/\*[\s\S]*?\*\//,atrule:{pattern:RegExp("@[\\w-](?:"+/[^;{\s"']|\s+(?!\s)/.source+"|"+t.source+")*?"+/(?:;|(?=\s*\{))/.source),inside:{rule:/^@[\w-]+/,"selector-function-argument":{pattern:/(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,lookbehind:!0,alias:"selector"},keyword:{pattern:/(^|[^\w-])(?:and|not|only|or)(?![\w-])/,lookbehind:!0}}},url:{pattern:RegExp("\\burl\\((?:"+t.source+"|"+/(?:[^\\\r\n()"']|\\[\s\S])*/.source+")\\)","i"),greedy:!0,inside:{function:/^url/i,punctuation:/^\(|\)$/,string:{pattern:RegExp("^"+t.source+"$"),alias:"url"}}},selector:{pattern:RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|"+t.source+")*(?=\\s*\\{)"),lookbehind:!0},string:{pattern:t,greedy:!0},property:{pattern:/(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,lookbehind:!0},important:/!important\b/i,function:{pattern:/(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,lookbehind:!0},punctuation:/[(){};:,]/},e.languages.css["atrule"].inside.rest=e.languages.css;var n=e.languages.markup;n&&(n.tag.addInlined("style","css"),n.tag.addAttribute("style","css"))}(a),a.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0,greedy:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},"class-name":{pattern:/(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,lookbehind:!0,inside:{punctuation:/[.\\]/}},keyword:/\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,boolean:/\b(?:false|true)\b/,function:/\b\w+(?=\()/,number:/\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,operator:/[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,punctuation:/[{}[\];(),.:]/},a.languages.javascript=a.languages.extend("clike",{"class-name":[a.languages.clike["class-name"],{pattern:/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,lookbehind:!0}],keyword:[{pattern:/((?:^|\})\s*)catch\b/,lookbehind:!0},{pattern:/(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,lookbehind:!0}],function:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,number:{pattern:RegExp(/(^|[^\w$])/.source+"(?:"+/NaN|Infinity/.source+"|"+/0[bB][01]+(?:_[01]+)*n?/.source+"|"+/0[oO][0-7]+(?:_[0-7]+)*n?/.source+"|"+/0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source+"|"+/\d+(?:_\d+)*n/.source+"|"+/(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source+")"+/(?![\w$])/.source),lookbehind:!0},operator:/--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/}),a.languages.javascript["class-name"][0].pattern=/(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/,a.languages.insertBefore("javascript","keyword",{regex:{pattern:RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source+/\//.source+"(?:"+/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source+"|"+/(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source+")"+/(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),lookbehind:!0,greedy:!0,inside:{"regex-source":{pattern:/^(\/)[\s\S]+(?=\/[a-z]*$)/,lookbehind:!0,alias:"language-regex",inside:a.languages.regex},"regex-delimiter":/^\/|\/$/,"regex-flags":/^[a-z]+$/}},"function-variable":{pattern:/#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,alias:"function"},parameter:[{pattern:/(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,lookbehind:!0,inside:a.languages.javascript},{pattern:/(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,lookbehind:!0,inside:a.languages.javascript},{pattern:/(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,lookbehind:!0,inside:a.languages.javascript},{pattern:/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,lookbehind:!0,inside:a.languages.javascript}],constant:/\b[A-Z](?:[A-Z_]|\dx?)*\b/}),a.languages.insertBefore("javascript","string",{hashbang:{pattern:/^#!.*/,greedy:!0,alias:"comment"},"template-string":{pattern:/`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,greedy:!0,inside:{"template-punctuation":{pattern:/^`|`$/,alias:"string"},interpolation:{pattern:/((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\$\{|\}$/,alias:"punctuation"},rest:a.languages.javascript}},string:/[\s\S]+/}},"string-property":{pattern:/((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,lookbehind:!0,greedy:!0,alias:"property"}}),a.languages.insertBefore("javascript","operator",{"literal-property":{pattern:/((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,lookbehind:!0,alias:"property"}}),a.languages.markup&&(a.languages.markup.tag.addInlined("script","javascript"),a.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,"javascript")),a.languages.js=a.languages.javascript,function(){if("undefined"!==typeof a&&"undefined"!==typeof document){Element.prototype.matches||(Element.prototype.matches=Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector);var e="Loading…",t=function(e,t){return"✖ Error "+e+" while fetching file: "+t},n="✖ Error: File does not exist or is empty",i={js:"javascript",py:"python",rb:"ruby",ps1:"powershell",psm1:"powershell",sh:"bash",bat:"batch",h:"c",tex:"latex"},r="data-src-status",s="loading",o="loaded",l="failed",u="pre[data-src]:not(["+r+'="'+o+'"]):not(['+r+'="'+s+'"])';a.hooks.add("before-highlightall",(function(e){e.selector+=", "+u})),a.hooks.add("before-sanity-check",(function(t){var n=t.element;if(n.matches(u)){t.code="",n.setAttribute(r,s);var c=n.appendChild(document.createElement("CODE"));c.textContent=e;var g=n.getAttribute("data-src"),h=t.language;if("none"===h){var f=(/\.(\w+)$/.exec(g)||[,"none"])[1];h=i[f]||f}a.util.setLanguage(c,h),a.util.setLanguage(n,h);var m=a.plugins.autoloader;m&&m.loadLanguages(h),d(g,(function(e){n.setAttribute(r,o);var t=p(n.getAttribute("data-range"));if(t){var i=e.split(/\r\n?|\n/g),s=t[0],l=null==t[1]?i.length:t[1];s<0&&(s+=i.length),s=Math.max(0,Math.min(s-1,i.length)),l<0&&(l+=i.length),l=Math.max(0,Math.min(l,i.length)),e=i.slice(s,l).join("\n"),n.hasAttribute("data-start")||n.setAttribute("data-start",String(s+1))}c.textContent=e,a.highlightElement(c)}),(function(e){n.setAttribute(r,l),c.textContent=e}))}})),a.plugins.fileHighlight={highlight:function(e){for(var t,n=(e||document).querySelectorAll(u),i=0;t=n[i++];)a.highlightElement(t)}};var c=!1;a.fileHighlight=function(){c||(console.warn("Prism.fileHighlight is deprecated. Use `Prism.plugins.fileHighlight.highlight` instead."),c=!0),a.plugins.fileHighlight.highlight.apply(this,arguments)}}function d(e,a,i){var r=new XMLHttpRequest;r.open("GET",e,!0),r.onreadystatechange=function(){4==r.readyState&&(r.status<400&&r.responseText?a(r.responseText):r.status>=400?i(t(r.status,r.statusText)):i(n))},r.send(null)}function p(e){var t=/^\s*(\d+)\s*(?:(,)\s*(?:(\d+)\s*)?)?$/.exec(e||"");if(t){var n=Number(t[1]),a=t[2],i=t[3];return a?i?[n,Number(i)]:[n,void 0]:[n,n]}}}()}).call(this,n("c8ba"))},cabf:function(e,t,n){var a=n("ac16");a.__esModule&&(a=a.default),"string"===typeof a&&(a=[[e.i,a,""]]),a.locals&&(e.exports=a.locals);var i=n("499e").default;i("3072be6e",a,!0,{sourceMap:!1,shadowMode:!1})}}]);
+//# sourceMappingURL=chunk-0c4e36c8.95d70738.js.map

dist/js/chunk-0cbfe13e.73856287.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-0cbfe13e"],{"00ce":function(e,t,r){"use strict";var o,n=r("a645"),i=r("417f"),a=r("dc99"),s=r("1409"),l=r("67ee"),c=r("0d25"),u=r("67d9"),p=Function,f=function(e){try{return p('"use strict"; return ('+e+").constructor;")()}catch(t){}},h=Object.getOwnPropertyDescriptor;if(h)try{h({},"")}catch(L){h=null}var y=function(){throw new c},d=h?function(){try{return y}catch(e){try{return h(arguments,"callee").get}catch(t){return y}}}():y,m=r("5156")(),g=r("0a36")(),b=Object.getPrototypeOf||(g?function(e){return e.__proto__}:null),v={},w="undefined"!==typeof Uint8Array&&b?b(Uint8Array):o,S={__proto__:null,"%AggregateError%":"undefined"===typeof AggregateError?o:AggregateError,"%Array%":Array,"%ArrayBuffer%":"undefined"===typeof ArrayBuffer?o:ArrayBuffer,"%ArrayIteratorPrototype%":m&&b?b([][Symbol.iterator]()):o,"%AsyncFromSyncIteratorPrototype%":o,"%AsyncFunction%":v,"%AsyncGenerator%":v,"%AsyncGeneratorFunction%":v,"%AsyncIteratorPrototype%":v,"%Atomics%":"undefined"===typeof Atomics?o:Atomics,"%BigInt%":"undefined"===typeof BigInt?o:BigInt,"%BigInt64Array%":"undefined"===typeof BigInt64Array?o:BigInt64Array,"%BigUint64Array%":"undefined"===typeof BigUint64Array?o:BigUint64Array,"%Boolean%":Boolean,"%DataView%":"undefined"===typeof DataView?o:DataView,"%Date%":Date,"%decodeURI%":decodeURI,"%decodeURIComponent%":decodeURIComponent,"%encodeURI%":encodeURI,"%encodeURIComponent%":encodeURIComponent,"%Error%":n,"%eval%":eval,"%EvalError%":i,"%Float32Array%":"undefined"===typeof Float32Array?o:Float32Array,"%Float64Array%":"undefined"===typeof Float64Array?o:Float64Array,"%FinalizationRegistry%":"undefined"===typeof FinalizationRegistry?o:FinalizationRegistry,"%Function%":p,"%GeneratorFunction%":v,"%Int8Array%":"undefined"===typeof Int8Array?o:Int8Array,"%Int16Array%":"undefined"===typeof Int16Array?o:Int16Array,"%Int32Array%":"undefined"===typeof Int32Array?o:Int32Array,"%isFinite%":isFinite,"%isNaN%":isNaN,"%IteratorPrototype%":m&&b?b(b([][Symbol.iterator]())):o,"%JSON%":"object"===typeof JSON?JSON:o,"%Map%":"undefined"===typeof Map?o:Map,"%MapIteratorPrototype%":"undefined"!==typeof Map&&m&&b?b((new Map)[Symbol.iterator]()):o,"%Math%":Math,"%Number%":Number,"%Object%":Object,"%parseFloat%":parseFloat,"%parseInt%":parseInt,"%Promise%":"undefined"===typeof Promise?o:Promise,"%Proxy%":"undefined"===typeof Proxy?o:Proxy,"%RangeError%":a,"%ReferenceError%":s,"%Reflect%":"undefined"===typeof Reflect?o:Reflect,"%RegExp%":RegExp,"%Set%":"undefined"===typeof Set?o:Set,"%SetIteratorPrototype%":"undefined"!==typeof Set&&m&&b?b((new Set)[Symbol.iterator]()):o,"%SharedArrayBuffer%":"undefined"===typeof SharedArrayBuffer?o:SharedArrayBuffer,"%String%":String,"%StringIteratorPrototype%":m&&b?b(""[Symbol.iterator]()):o,"%Symbol%":m?Symbol:o,"%SyntaxError%":l,"%ThrowTypeError%":d,"%TypedArray%":w,"%TypeError%":c,"%Uint8Array%":"undefined"===typeof Uint8Array?o:Uint8Array,"%Uint8ClampedArray%":"undefined"===typeof Uint8ClampedArray?o:Uint8ClampedArray,"%Uint16Array%":"undefined"===typeof Uint16Array?o:Uint16Array,"%Uint32Array%":"undefined"===typeof Uint32Array?o:Uint32Array,"%URIError%":u,"%WeakMap%":"undefined"===typeof WeakMap?o:WeakMap,"%WeakRef%":"undefined"===typeof WeakRef?o:WeakRef,"%WeakSet%":"undefined"===typeof WeakSet?o:WeakSet};if(b)try{null.error}catch(L){var x=b(b(L));S["%Error.prototype%"]=x}var O=function e(t){var r;if("%AsyncFunction%"===t)r=f("async function () {}");else if("%GeneratorFunction%"===t)r=f("function* () {}");else if("%AsyncGeneratorFunction%"===t)r=f("async function* () {}");else if("%AsyncGenerator%"===t){var o=e("%AsyncGeneratorFunction%");o&&(r=o.prototype)}else if("%AsyncIteratorPrototype%"===t){var n=e("%AsyncGenerator%");n&&b&&(r=b(n.prototype))}return S[t]=r,r},j={__proto__:null,"%ArrayBufferPrototype%":["ArrayBuffer","prototype"],"%ArrayPrototype%":["Array","prototype"],"%ArrayProto_entries%":["Array","prototype","entries"],"%ArrayProto_forEach%":["Array","prototype","forEach"],"%ArrayProto_keys%":["Array","prototype","keys"],"%ArrayProto_values%":["Array","prototype","values"],"%AsyncFunctionPrototype%":["AsyncFunction","prototype"],"%AsyncGenerator%":["AsyncGeneratorFunction","prototype"],"%AsyncGeneratorPrototype%":["AsyncGeneratorFunction","prototype","prototype"],"%BooleanPrototype%":["Boolean","prototype"],"%DataViewPrototype%":["DataView","prototype"],"%DatePrototype%":["Date","prototype"],"%ErrorPrototype%":["Error","prototype"],"%EvalErrorPrototype%":["EvalError","prototype"],"%Float32ArrayPrototype%":["Float32Array","prototype"],"%Float64ArrayPrototype%":["Float64Array","prototype"],"%FunctionPrototype%":["Function","prototype"],"%Generator%":["GeneratorFunction","prototype"],"%GeneratorPrototype%":["GeneratorFunction","prototype","prototype"],"%Int8ArrayPrototype%":["Int8Array","prototype"],"%Int16ArrayPrototype%":["Int16Array","prototype"],"%Int32ArrayPrototype%":["Int32Array","prototype"],"%JSONParse%":["JSON","parse"],"%JSONStringify%":["JSON","stringify"],"%MapPrototype%":["Map","prototype"],"%NumberPrototype%":["Number","prototype"],"%ObjectPrototype%":["Object","prototype"],"%ObjProto_toString%":["Object","prototype","toString"],"%ObjProto_valueOf%":["Object","prototype","valueOf"],"%PromisePrototype%":["Promise","prototype"],"%PromiseProto_then%":["Promise","prototype","then"],"%Promise_all%":["Promise","all"],"%Promise_reject%":["Promise","reject"],"%Promise_resolve%":["Promise","resolve"],"%RangeErrorPrototype%":["RangeError","prototype"],"%ReferenceErrorPrototype%":["ReferenceError","prototype"],"%RegExpPrototype%":["RegExp","prototype"],"%SetPrototype%":["Set","prototype"],"%SharedArrayBufferPrototype%":["SharedArrayBuffer","prototype"],"%StringPrototype%":["String","prototype"],"%SymbolPrototype%":["Symbol","prototype"],"%SyntaxErrorPrototype%":["SyntaxError","prototype"],"%TypedArrayPrototype%":["TypedArray","prototype"],"%TypeErrorPrototype%":["TypeError","prototype"],"%Uint8ArrayPrototype%":["Uint8Array","prototype"],"%Uint8ClampedArrayPrototype%":["Uint8ClampedArray","prototype"],"%Uint16ArrayPrototype%":["Uint16Array","prototype"],"%Uint32ArrayPrototype%":["Uint32Array","prototype"],"%URIErrorPrototype%":["URIError","prototype"],"%WeakMapPrototype%":["WeakMap","prototype"],"%WeakSetPrototype%":["WeakSet","prototype"]},A=r("0f7c"),P=r("9671"),k=A.call(Function.call,Array.prototype.concat),E=A.call(Function.apply,Array.prototype.splice),I=A.call(Function.call,String.prototype.replace),_=A.call(Function.call,String.prototype.slice),T=A.call(Function.call,RegExp.prototype.exec),N=/[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,C=/\\(\\)?/g,F=function(e){var t=_(e,0,1),r=_(e,-1);if("%"===t&&"%"!==r)throw new l("invalid intrinsic syntax, expected closing `%`");if("%"===r&&"%"!==t)throw new l("invalid intrinsic syntax, expected opening `%`");var o=[];return I(e,N,(function(e,t,r,n){o[o.length]=r?I(n,C,"$1"):t||e})),o},R=function(e,t){var r,o=e;if(P(j,o)&&(r=j[o],o="%"+r[0]+"%"),P(S,o)){var n=S[o];if(n===v&&(n=O(o)),"undefined"===typeof n&&!t)throw new c("intrinsic "+e+" exists, but is not available. Please file an issue!");return{alias:r,name:o,value:n}}throw new l("intrinsic "+e+" does not exist!")};e.exports=function(e,t){if("string"!==typeof e||0===e.length)throw new c("intrinsic name must be a non-empty string");if(arguments.length>1&&"boolean"!==typeof t)throw new c('"allowMissing" argument must be a boolean');if(null===T(/^%?[^%]*%?$/,e))throw new l("`%` may not be present anywhere but at the beginning and end of the intrinsic name");var r=F(e),o=r.length>0?r[0]:"",n=R("%"+o+"%",t),i=n.name,a=n.value,s=!1,u=n.alias;u&&(o=u[0],E(r,k([0,1],u)));for(var p=1,f=!0;p<r.length;p+=1){var y=r[p],d=_(y,0,1),m=_(y,-1);if(('"'===d||"'"===d||"`"===d||'"'===m||"'"===m||"`"===m)&&d!==m)throw new l("property names with quotes must have matching quotes");if("constructor"!==y&&f||(s=!0),o+="."+y,i="%"+o+"%",P(S,i))a=S[i];else if(null!=a){if(!(y in a)){if(!t)throw new c("base intrinsic for "+e+" exists, but the property is not available.");return}if(h&&p+1>=r.length){var g=h(a,y);f=!!g,a=f&&"get"in g&&!("originalValue"in g.get)?g.get:a[y]}else f=P(a,y),a=a[y];f&&!s&&(S[i]=a)}}return a}},"0a36":function(e,t,r){"use strict";var o={__proto__:null,foo:{}},n=Object;e.exports=function(){return{__proto__:o}.foo===o.foo&&!(o instanceof n)}},"0b16":function(e,t,r){"use strict";var o=r("9d88");function n(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}var i=/^([a-z0-9.+-]+:)/i,a=/:[0-9]*$/,s=/^(\/\/?(?!\/)[^?\s]*)(\?[^\s]*)?$/,l=["<",">",'"',"`"," ","\r","\n","\t"],c=["{","}","|","\\","^","`"].concat(l),u=["'"].concat(c),p=["%","/","?",";","#"].concat(u),f=["/","?","#"],h=255,y=/^[+a-z0-9A-Z_-]{0,63}$/,d=/^([+a-z0-9A-Z_-]{0,63})(.*)$/,m={javascript:!0,"javascript:":!0},g={javascript:!0,"javascript:":!0},b={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},v=r("184d");function w(e,t,r){if(e&&"object"===typeof e&&e instanceof n)return e;var o=new n;return o.parse(e,t,r),o}function S(e){return"string"===typeof e&&(e=w(e)),e instanceof n?e.format():n.prototype.format.call(e)}function x(e,t){return w(e,!1,!0).resolve(t)}function O(e,t){return e?w(e,!1,!0).resolveObject(t):t}n.prototype.parse=function(e,t,r){if("string"!==typeof e)throw new TypeError("Parameter 'url' must be a string, not "+typeof e);var n=e.indexOf("?"),a=-1!==n&&n<e.indexOf("#")?"?":"#",l=e.split(a),c=/\\/g;l[0]=l[0].replace(c,"/"),e=l.join(a);var w=e;if(w=w.trim(),!r&&1===e.split("#").length){var S=s.exec(w);if(S)return this.path=w,this.href=w,this.pathname=S[1],S[2]?(this.search=S[2],this.query=t?v.parse(this.search.substr(1)):this.search.substr(1)):t&&(this.search="",this.query={}),this}var x=i.exec(w);if(x){x=x[0];var O=x.toLowerCase();this.protocol=O,w=w.substr(x.length)}if(r||x||w.match(/^\/\/[^@/]+@[^@/]+/)){var j="//"===w.substr(0,2);!j||x&&g[x]||(w=w.substr(2),this.slashes=!0)}if(!g[x]&&(j||x&&!b[x])){for(var A,P,k=-1,E=0;E<f.length;E++){var I=w.indexOf(f[E]);-1!==I&&(-1===k||I<k)&&(k=I)}P=-1===k?w.lastIndexOf("@"):w.lastIndexOf("@",k),-1!==P&&(A=w.slice(0,P),w=w.slice(P+1),this.auth=decodeURIComponent(A)),k=-1;for(E=0;E<p.length;E++){I=w.indexOf(p[E]);-1!==I&&(-1===k||I<k)&&(k=I)}-1===k&&(k=w.length),this.host=w.slice(0,k),w=w.slice(k),this.parseHost(),this.hostname=this.hostname||"";var _="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!_)for(var T=this.hostname.split(/\./),N=(E=0,T.length);E<N;E++){var C=T[E];if(C&&!C.match(y)){for(var F="",R=0,L=C.length;R<L;R++)C.charCodeAt(R)>127?F+="x":F+=C[R];if(!F.match(y)){var D=T.slice(0,E),M=T.slice(E+1),U=C.match(d);U&&(D.push(U[1]),M.unshift(U[2])),M.length&&(w="/"+M.join(".")+w),this.hostname=D.join(".");break}}}this.hostname.length>h?this.hostname="":this.hostname=this.hostname.toLowerCase(),_||(this.hostname=o.toASCII(this.hostname));var B=this.port?":"+this.port:"",W=this.hostname||"";this.host=W+B,this.href+=this.host,_&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==w[0]&&(w="/"+w))}if(!m[O])for(E=0,N=u.length;E<N;E++){var q=u[E];if(-1!==w.indexOf(q)){var $=encodeURIComponent(q);$===q&&($=escape(q)),w=w.split(q).join($)}}var H=w.indexOf("#");-1!==H&&(this.hash=w.substr(H),w=w.slice(0,H));var G=w.indexOf("?");if(-1!==G?(this.search=w.substr(G),this.query=w.substr(G+1),t&&(this.query=v.parse(this.query)),w=w.slice(0,G)):t&&(this.search="",this.query={}),w&&(this.pathname=w),b[O]&&this.hostname&&!this.pathname&&(this.pathname="/"),this.pathname||this.search){B=this.pathname||"";var J=this.search||"";this.path=B+J}return this.href=this.format(),this},n.prototype.format=function(){var e=this.auth||"";e&&(e=encodeURIComponent(e),e=e.replace(/%3A/i,":"),e+="@");var t=this.protocol||"",r=this.pathname||"",o=this.hash||"",n=!1,i="";this.host?n=e+this.host:this.hostname&&(n=e+(-1===this.hostname.indexOf(":")?this.hostname:"["+this.hostname+"]"),this.port&&(n+=":"+this.port)),this.query&&"object"===typeof this.query&&Object.keys(this.query).length&&(i=v.stringify(this.query,{arrayFormat:"repeat",addQueryPrefix:!1}));var a=this.search||i&&"?"+i||"";return t&&":"!==t.substr(-1)&&(t+=":"),this.slashes||(!t||b[t])&&!1!==n?(n="//"+(n||""),r&&"/"!==r.charAt(0)&&(r="/"+r)):n||(n=""),o&&"#"!==o.charAt(0)&&(o="#"+o),a&&"?"!==a.charAt(0)&&(a="?"+a),r=r.replace(/[?#]/g,(function(e){return encodeURIComponent(e)})),a=a.replace("#","%23"),t+n+r+a+o},n.prototype.resolve=function(e){return this.resolveObject(w(e,!1,!0)).format()},n.prototype.resolveObject=function(e){if("string"===typeof e){var t=new n;t.parse(e,!1,!0),e=t}for(var r=new n,o=Object.keys(this),i=0;i<o.length;i++){var a=o[i];r[a]=this[a]}if(r.hash=e.hash,""===e.href)return r.href=r.format(),r;if(e.slashes&&!e.protocol){for(var s=Object.keys(e),l=0;l<s.length;l++){var c=s[l];"protocol"!==c&&(r[c]=e[c])}return b[r.protocol]&&r.hostname&&!r.pathname&&(r.pathname="/",r.path=r.pathname),r.href=r.format(),r}if(e.protocol&&e.protocol!==r.protocol){if(!b[e.protocol]){for(var u=Object.keys(e),p=0;p<u.length;p++){var f=u[p];r[f]=e[f]}return r.href=r.format(),r}if(r.protocol=e.protocol,e.host||g[e.protocol])r.pathname=e.pathname;else{var h=(e.pathname||"").split("/");while(h.length&&!(e.host=h.shift()));e.host||(e.host=""),e.hostname||(e.hostname=""),""!==h[0]&&h.unshift(""),h.length<2&&h.unshift(""),r.pathname=h.join("/")}if(r.search=e.search,r.query=e.query,r.host=e.host||"",r.auth=e.auth,r.hostname=e.hostname||e.host,r.port=e.port,r.pathname||r.search){var y=r.pathname||"",d=r.search||"";r.path=y+d}return r.slashes=r.slashes||e.slashes,r.href=r.format(),r}var m=r.pathname&&"/"===r.pathname.charAt(0),v=e.host||e.pathname&&"/"===e.pathname.charAt(0),w=v||m||r.host&&e.pathname,S=w,x=r.pathname&&r.pathname.split("/")||[],O=(h=e.pathname&&e.pathname.split("/")||[],r.protocol&&!b[r.protocol]);if(O&&(r.hostname="",r.port=null,r.host&&(""===x[0]?x[0]=r.host:x.unshift(r.host)),r.host="",e.protocol&&(e.hostname=null,e.port=null,e.host&&(""===h[0]?h[0]=e.host:h.unshift(e.host)),e.host=null),w=w&&(""===h[0]||""===x[0])),v)r.host=e.host||""===e.host?e.host:r.host,r.hostname=e.hostname||""===e.hostname?e.hostname:r.hostname,r.search=e.search,r.query=e.query,x=h;else if(h.length)x||(x=[]),x.pop(),x=x.concat(h),r.search=e.search,r.query=e.query;else if(null!=e.search){if(O){r.host=x.shift(),r.hostname=r.host;var j=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@");j&&(r.auth=j.shift(),r.hostname=j.shift(),r.host=r.hostname)}return r.search=e.search,r.query=e.query,null===r.pathname&&null===r.search||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.href=r.format(),r}if(!x.length)return r.pathname=null,r.search?r.path="/"+r.search:r.path=null,r.href=r.format(),r;for(var A=x.slice(-1)[0],P=(r.host||e.host||x.length>1)&&("."===A||".."===A)||""===A,k=0,E=x.length;E>=0;E--)A=x[E],"."===A?x.splice(E,1):".."===A?(x.splice(E,1),k++):k&&(x.splice(E,1),k--);if(!w&&!S)for(;k--;k)x.unshift("..");!w||""===x[0]||x[0]&&"/"===x[0].charAt(0)||x.unshift(""),P&&"/"!==x.join("/").substr(-1)&&x.push("");var I=""===x[0]||x[0]&&"/"===x[0].charAt(0);if(O){r.hostname=I?"":x.length?x.shift():"",r.host=r.hostname;j=!!(r.host&&r.host.indexOf("@")>0)&&r.host.split("@");j&&(r.auth=j.shift(),r.hostname=j.shift(),r.host=r.hostname)}return w=w||r.host&&x.length,w&&!I&&x.unshift(""),x.length>0?r.pathname=x.join("/"):(r.pathname=null,r.path=null),null===r.pathname&&null===r.search||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.auth=e.auth||r.auth,r.slashes=r.slashes||e.slashes,r.href=r.format(),r},n.prototype.parseHost=function(){var e=this.host,t=a.exec(e);t&&(t=t[0],":"!==t&&(this.port=t.substr(1)),e=e.substr(0,e.length-t.length)),e&&(this.hostname=e)},t.parse=w,t.resolve=x,t.resolveObject=O,t.format=S,t.Url=n},"0d25":function(e,t,r){"use strict";e.exports=TypeError},"0f7c":function(e,t,r){"use strict";var o=r("688e");e.exports=Function.prototype.bind||o},1:function(e,t){},1409:function(e,t,r){"use strict";e.exports=ReferenceError},1696:function(e,t,r){"use strict";e.exports=function(){if("function"!==typeof Symbol||"function"!==typeof Object.getOwnPropertySymbols)return!1;if("symbol"===typeof Symbol.iterator)return!0;var e={},t=Symbol("test"),r=Object(t);if("string"===typeof t)return!1;if("[object Symbol]"!==Object.prototype.toString.call(t))return!1;if("[object Symbol]"!==Object.prototype.toString.call(r))return!1;var o=42;for(t in e[t]=o,e)return!1;if("function"===typeof Object.keys&&0!==Object.keys(e).length)return!1;if("function"===typeof Object.getOwnPropertyNames&&0!==Object.getOwnPropertyNames(e).length)return!1;var n=Object.getOwnPropertySymbols(e);if(1!==n.length||n[0]!==t)return!1;if(!Object.prototype.propertyIsEnumerable.call(e,t))return!1;if("function"===typeof Object.getOwnPropertyDescriptor){var i=Object.getOwnPropertyDescriptor(e,t);if(i.value!==o||!0!==i.enumerable)return!1}return!0}},"184d":function(e,t,r){"use strict";var o=r("f177"),n=r("2500"),i=r("bbc7");e.exports={formats:i,parse:n,stringify:o}},2500:function(e,t,r){"use strict";var o=r("a29f"),n=Object.prototype.hasOwnProperty,i=Array.isArray,a={allowDots:!1,allowEmptyArrays:!1,allowPrototypes:!1,allowSparse:!1,arrayLimit:20,charset:"utf-8",charsetSentinel:!1,comma:!1,decodeDotInKeys:!1,decoder:o.decode,delimiter:"&",depth:5,duplicates:"combine",ignoreQueryPrefix:!1,interpretNumericEntities:!1,parameterLimit:1e3,parseArrays:!0,plainObjects:!1,strictDepth:!1,strictNullHandling:!1},s=function(e){return e.replace(/&#(\d+);/g,(function(e,t){return String.fromCharCode(parseInt(t,10))}))},l=function(e,t){return e&&"string"===typeof e&&t.comma&&e.indexOf(",")>-1?e.split(","):e},c="utf8=%26%2310003%3B",u="utf8=%E2%9C%93",p=function(e,t){var r={__proto__:null},p=t.ignoreQueryPrefix?e.replace(/^\?/,""):e;p=p.replace(/%5B/gi,"[").replace(/%5D/gi,"]");var f,h=t.parameterLimit===1/0?void 0:t.parameterLimit,y=p.split(t.delimiter,h),d=-1,m=t.charset;if(t.charsetSentinel)for(f=0;f<y.length;++f)0===y[f].indexOf("utf8=")&&(y[f]===u?m="utf-8":y[f]===c&&(m="iso-8859-1"),d=f,f=y.length);for(f=0;f<y.length;++f)if(f!==d){var g,b,v=y[f],w=v.indexOf("]="),S=-1===w?v.indexOf("="):w+1;-1===S?(g=t.decoder(v,a.decoder,m,"key"),b=t.strictNullHandling?null:""):(g=t.decoder(v.slice(0,S),a.decoder,m,"key"),b=o.maybeMap(l(v.slice(S+1),t),(function(e){return t.decoder(e,a.decoder,m,"value")}))),b&&t.interpretNumericEntities&&"iso-8859-1"===m&&(b=s(String(b))),v.indexOf("[]=")>-1&&(b=i(b)?[b]:b);var x=n.call(r,g);x&&"combine"===t.duplicates?r[g]=o.combine(r[g],b):x&&"last"!==t.duplicates||(r[g]=b)}return r},f=function(e,t,r,o){for(var n=o?t:l(t,r),i=e.length-1;i>=0;--i){var a,s=e[i];if("[]"===s&&r.parseArrays)a=r.allowEmptyArrays&&(""===n||r.strictNullHandling&&null===n)?[]:[].concat(n);else{a=r.plainObjects?{__proto__:null}:{};var c="["===s.charAt(0)&&"]"===s.charAt(s.length-1)?s.slice(1,-1):s,u=r.decodeDotInKeys?c.replace(/%2E/g,"."):c,p=parseInt(u,10);r.parseArrays||""!==u?!isNaN(p)&&s!==u&&String(p)===u&&p>=0&&r.parseArrays&&p<=r.arrayLimit?(a=[],a[p]=n):"__proto__"!==u&&(a[u]=n):a={0:n}}n=a}return n},h=function(e,t,r,o){if(e){var i=r.allowDots?e.replace(/\.([^.[]+)/g,"[$1]"):e,a=/(\[[^[\]]*])/,s=/(\[[^[\]]*])/g,l=r.depth>0&&a.exec(i),c=l?i.slice(0,l.index):i,u=[];if(c){if(!r.plainObjects&&n.call(Object.prototype,c)&&!r.allowPrototypes)return;u.push(c)}var p=0;while(r.depth>0&&null!==(l=s.exec(i))&&p<r.depth){if(p+=1,!r.plainObjects&&n.call(Object.prototype,l[1].slice(1,-1))&&!r.allowPrototypes)return;u.push(l[1])}if(l){if(!0===r.strictDepth)throw new RangeError("Input depth exceeded depth option of "+r.depth+" and strictDepth is true");u.push("["+i.slice(l.index)+"]")}return f(u,t,r,o)}},y=function(e){if(!e)return a;if("undefined"!==typeof e.allowEmptyArrays&&"boolean"!==typeof e.allowEmptyArrays)throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");if("undefined"!==typeof e.decodeDotInKeys&&"boolean"!==typeof e.decodeDotInKeys)throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");if(null!==e.decoder&&"undefined"!==typeof e.decoder&&"function"!==typeof e.decoder)throw new TypeError("Decoder has to be a function.");if("undefined"!==typeof e.charset&&"utf-8"!==e.charset&&"iso-8859-1"!==e.charset)throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");var t="undefined"===typeof e.charset?a.charset:e.charset,r="undefined"===typeof e.duplicates?a.duplicates:e.duplicates;if("combine"!==r&&"first"!==r&&"last"!==r)throw new TypeError("The duplicates option must be either combine, first, or last");var n="undefined"===typeof e.allowDots?!0===e.decodeDotInKeys||a.allowDots:!!e.allowDots;return{allowDots:n,allowEmptyArrays:"boolean"===typeof e.allowEmptyArrays?!!e.allowEmptyArrays:a.allowEmptyArrays,allowPrototypes:"boolean"===typeof e.allowPrototypes?e.allowPrototypes:a.allowPrototypes,allowSparse:"boolean"===typeof e.allowSparse?e.allowSparse:a.allowSparse,arrayLimit:"number"===typeof e.arrayLimit?e.arrayLimit:a.arrayLimit,charset:t,charsetSentinel:"boolean"===typeof e.charsetSentinel?e.charsetSentinel:a.charsetSentinel,comma:"boolean"===typeof e.comma?e.comma:a.comma,decodeDotInKeys:"boolean"===typeof e.decodeDotInKeys?e.decodeDotInKeys:a.decodeDotInKeys,decoder:"function"===typeof e.decoder?e.decoder:a.decoder,delimiter:"string"===typeof e.delimiter||o.isRegExp(e.delimiter)?e.delimiter:a.delimiter,depth:"number"===typeof e.depth||!1===e.depth?+e.depth:a.depth,duplicates:r,ignoreQueryPrefix:!0===e.ignoreQueryPrefix,interpretNumericEntities:"boolean"===typeof e.interpretNumericEntities?e.interpretNumericEntities:a.interpretNumericEntities,parameterLimit:"number"===typeof e.parameterLimit?e.parameterLimit:a.parameterLimit,parseArrays:!1!==e.parseArrays,plainObjects:"boolean"===typeof e.plainObjects?e.plainObjects:a.plainObjects,strictDepth:"boolean"===typeof e.strictDepth?!!e.strictDepth:a.strictDepth,strictNullHandling:"boolean"===typeof e.strictNullHandling?e.strictNullHandling:a.strictNullHandling}};e.exports=function(e,t){var r=y(t);if(""===e||null===e||"undefined"===typeof e)return r.plainObjects?{__proto__:null}:{};for(var n="string"===typeof e?p(e,r):e,i=r.plainObjects?{__proto__:null}:{},a=Object.keys(n),s=0;s<a.length;++s){var l=a[s],c=h(l,n[l],r,"string"===typeof e);i=o.merge(i,c,r)}return!0===r.allowSparse?i:o.compact(i)}},2714:function(e,t,r){(function(t){var o="function"===typeof Map&&Map.prototype,n=Object.getOwnPropertyDescriptor&&o?Object.getOwnPropertyDescriptor(Map.prototype,"size"):null,i=o&&n&&"function"===typeof n.get?n.get:null,a=o&&Map.prototype.forEach,s="function"===typeof Set&&Set.prototype,l=Object.getOwnPropertyDescriptor&&s?Object.getOwnPropertyDescriptor(Set.prototype,"size"):null,c=s&&l&&"function"===typeof l.get?l.get:null,u=s&&Set.prototype.forEach,p="function"===typeof WeakMap&&WeakMap.prototype,f=p?WeakMap.prototype.has:null,h="function"===typeof WeakSet&&WeakSet.prototype,y=h?WeakSet.prototype.has:null,d="function"===typeof WeakRef&&WeakRef.prototype,m=d?WeakRef.prototype.deref:null,g=Boolean.prototype.valueOf,b=Object.prototype.toString,v=Function.prototype.toString,w=String.prototype.match,S=String.prototype.slice,x=String.prototype.replace,O=String.prototype.toUpperCase,j=String.prototype.toLowerCase,A=RegExp.prototype.test,P=Array.prototype.concat,k=Array.prototype.join,E=Array.prototype.slice,I=Math.floor,_="function"===typeof BigInt?BigInt.prototype.valueOf:null,T=Object.getOwnPropertySymbols,N="function"===typeof Symbol&&"symbol"===typeof Symbol.iterator?Symbol.prototype.toString:null,C="function"===typeof Symbol&&"object"===typeof Symbol.iterator,F="function"===typeof Symbol&&Symbol.toStringTag&&(typeof Symbol.toStringTag===C||"symbol")?Symbol.toStringTag:null,R=Object.prototype.propertyIsEnumerable,L=("function"===typeof Reflect?Reflect.getPrototypeOf:Object.getPrototypeOf)||([].__proto__===Array.prototype?function(e){return e.__proto__}:null);function D(e,t){if(e===1/0||e===-1/0||e!==e||e&&e>-1e3&&e<1e3||A.call(/e/,t))return t;var r=/[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;if("number"===typeof e){var o=e<0?-I(-e):I(e);if(o!==e){var n=String(o),i=S.call(t,n.length+1);return x.call(n,r,"$&_")+"."+x.call(x.call(i,/([0-9]{3})/g,"$&_"),/_$/,"")}}return x.call(t,r,"$&_")}var M=r(1),U=M.custom,B=X(U)?U:null,W={__proto__:null,double:'"',single:"'"},q={__proto__:null,double:/(["\\])/g,single:/(['\\])/g};function $(e,t,r){var o=r.quoteStyle||t,n=W[o];return n+e+n}function H(e){return x.call(String(e),/"/g,"&quot;")}function G(e){return"[object Array]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function J(e){return"[object Date]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function K(e){return"[object RegExp]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function z(e){return"[object Error]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function V(e){return"[object String]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function Q(e){return"[object Number]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function Z(e){return"[object Boolean]"===re(e)&&(!F||!("object"===typeof e&&F in e))}function X(e){if(C)return e&&"object"===typeof e&&e instanceof Symbol;if("symbol"===typeof e)return!0;if(!e||"object"!==typeof e||!N)return!1;try{return N.call(e),!0}catch(t){}return!1}function Y(e){if(!e||"object"!==typeof e||!_)return!1;try{return _.call(e),!0}catch(t){}return!1}e.exports=function e(r,o,n,s){var l=o||{};if(te(l,"quoteStyle")&&!te(W,l.quoteStyle))throw new TypeError('option "quoteStyle" must be "single" or "double"');if(te(l,"maxStringLength")&&("number"===typeof l.maxStringLength?l.maxStringLength<0&&l.maxStringLength!==1/0:null!==l.maxStringLength))throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');var p=!te(l,"customInspect")||l.customInspect;if("boolean"!==typeof p&&"symbol"!==p)throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");if(te(l,"indent")&&null!==l.indent&&"\t"!==l.indent&&!(parseInt(l.indent,10)===l.indent&&l.indent>0))throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');if(te(l,"numericSeparator")&&"boolean"!==typeof l.numericSeparator)throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');var f=l.numericSeparator;if("undefined"===typeof r)return"undefined";if(null===r)return"null";if("boolean"===typeof r)return r?"true":"false";if("string"===typeof r)return pe(r,l);if("number"===typeof r){if(0===r)return 1/0/r>0?"0":"-0";var h=String(r);return f?D(r,h):h}if("bigint"===typeof r){var y=String(r)+"n";return f?D(r,y):y}var d="undefined"===typeof l.depth?5:l.depth;if("undefined"===typeof n&&(n=0),n>=d&&d>0&&"object"===typeof r)return G(r)?"[Array]":"[Object]";var m=ge(l,n);if("undefined"===typeof s)s=[];else if(ne(s,r)>=0)return"[Circular]";function b(t,r,o){if(r&&(s=E.call(s),s.push(r)),o){var i={depth:l.depth};return te(l,"quoteStyle")&&(i.quoteStyle=l.quoteStyle),e(t,i,n+1,s)}return e(t,l,n+1,s)}if("function"===typeof r&&!K(r)){var v=oe(r),w=ve(r,b);return"[Function"+(v?": "+v:" (anonymous)")+"]"+(w.length>0?" { "+k.call(w,", ")+" }":"")}if(X(r)){var O=C?x.call(String(r),/^(Symbol\(.*\))_[^)]*$/,"$1"):N.call(r);return"object"!==typeof r||C?O:he(O)}if(ue(r)){for(var A="<"+j.call(String(r.nodeName)),I=r.attributes||[],T=0;T<I.length;T++)A+=" "+I[T].name+"="+$(H(I[T].value),"double",l);return A+=">",r.childNodes&&r.childNodes.length&&(A+="..."),A+="</"+j.call(String(r.nodeName))+">",A}if(G(r)){if(0===r.length)return"[]";var U=ve(r,b);return m&&!me(U)?"["+be(U,m)+"]":"[ "+k.call(U,", ")+" ]"}if(z(r)){var q=ve(r,b);return"cause"in Error.prototype||!("cause"in r)||R.call(r,"cause")?0===q.length?"["+String(r)+"]":"{ ["+String(r)+"] "+k.call(q,", ")+" }":"{ ["+String(r)+"] "+k.call(P.call("[cause]: "+b(r.cause),q),", ")+" }"}if("object"===typeof r&&p){if(B&&"function"===typeof r[B]&&M)return M(r,{depth:d-n});if("symbol"!==p&&"function"===typeof r.inspect)return r.inspect()}if(ie(r)){var ee=[];return a&&a.call(r,(function(e,t){ee.push(b(t,r,!0)+" => "+b(e,r))})),de("Map",i.call(r),ee,m)}if(le(r)){var fe=[];return u&&u.call(r,(function(e){fe.push(b(e,r))})),de("Set",c.call(r),fe,m)}if(ae(r))return ye("WeakMap");if(ce(r))return ye("WeakSet");if(se(r))return ye("WeakRef");if(Q(r))return he(b(Number(r)));if(Y(r))return he(b(_.call(r)));if(Z(r))return he(g.call(r));if(V(r))return he(b(String(r)));if("undefined"!==typeof window&&r===window)return"{ [object Window] }";if("undefined"!==typeof globalThis&&r===globalThis||"undefined"!==typeof t&&r===t)return"{ [object globalThis] }";if(!J(r)&&!K(r)){var we=ve(r,b),Se=L?L(r)===Object.prototype:r instanceof Object||r.constructor===Object,xe=r instanceof Object?"":"null prototype",Oe=!Se&&F&&Object(r)===r&&F in r?S.call(re(r),8,-1):xe?"Object":"",je=Se||"function"!==typeof r.constructor?"":r.constructor.name?r.constructor.name+" ":"",Ae=je+(Oe||xe?"["+k.call(P.call([],Oe||[],xe||[]),": ")+"] ":"");return 0===we.length?Ae+"{}":m?Ae+"{"+be(we,m)+"}":Ae+"{ "+k.call(we,", ")+" }"}return String(r)};var ee=Object.prototype.hasOwnProperty||function(e){return e in this};function te(e,t){return ee.call(e,t)}function re(e){return b.call(e)}function oe(e){if(e.name)return e.name;var t=w.call(v.call(e),/^function\s*([\w$]+)/);return t?t[1]:null}function ne(e,t){if(e.indexOf)return e.indexOf(t);for(var r=0,o=e.length;r<o;r++)if(e[r]===t)return r;return-1}function ie(e){if(!i||!e||"object"!==typeof e)return!1;try{i.call(e);try{c.call(e)}catch(t){return!0}return e instanceof Map}catch(r){}return!1}function ae(e){if(!f||!e||"object"!==typeof e)return!1;try{f.call(e,f);try{y.call(e,y)}catch(t){return!0}return e instanceof WeakMap}catch(r){}return!1}function se(e){if(!m||!e||"object"!==typeof e)return!1;try{return m.call(e),!0}catch(t){}return!1}function le(e){if(!c||!e||"object"!==typeof e)return!1;try{c.call(e);try{i.call(e)}catch(t){return!0}return e instanceof Set}catch(r){}return!1}function ce(e){if(!y||!e||"object"!==typeof e)return!1;try{y.call(e,y);try{f.call(e,f)}catch(t){return!0}return e instanceof WeakSet}catch(r){}return!1}function ue(e){return!(!e||"object"!==typeof e)&&("undefined"!==typeof HTMLElement&&e instanceof HTMLElement||"string"===typeof e.nodeName&&"function"===typeof e.getAttribute)}function pe(e,t){if(e.length>t.maxStringLength){var r=e.length-t.maxStringLength,o="... "+r+" more character"+(r>1?"s":"");return pe(S.call(e,0,t.maxStringLength),t)+o}var n=q[t.quoteStyle||"single"];n.lastIndex=0;var i=x.call(x.call(e,n,"\\$1"),/[\x00-\x1f]/g,fe);return $(i,"single",t)}function fe(e){var t=e.charCodeAt(0),r={8:"b",9:"t",10:"n",12:"f",13:"r"}[t];return r?"\\"+r:"\\x"+(t<16?"0":"")+O.call(t.toString(16))}function he(e){return"Object("+e+")"}function ye(e){return e+" { ? }"}function de(e,t,r,o){var n=o?be(r,o):k.call(r,", ");return e+" ("+t+") {"+n+"}"}function me(e){for(var t=0;t<e.length;t++)if(ne(e[t],"\n")>=0)return!1;return!0}function ge(e,t){var r;if("\t"===e.indent)r="\t";else{if(!("number"===typeof e.indent&&e.indent>0))return null;r=k.call(Array(e.indent+1)," ")}return{base:r,prev:k.call(Array(t+1),r)}}function be(e,t){if(0===e.length)return"";var r="\n"+t.prev+t.base;return r+k.call(e,","+r)+"\n"+t.prev}function ve(e,t){var r=G(e),o=[];if(r){o.length=e.length;for(var n=0;n<e.length;n++)o[n]=te(e,n)?t(e[n],e):""}var i,a="function"===typeof T?T(e):[];if(C){i={};for(var s=0;s<a.length;s++)i["$"+a[s]]=a[s]}for(var l in e)te(e,l)&&(r&&String(Number(l))===l&&l<e.length||C&&i["$"+l]instanceof Symbol||(A.call(/[^\w$]/,l)?o.push(t(l,e)+": "+t(e[l],e)):o.push(l+": "+t(e[l],e))));if("function"===typeof T)for(var c=0;c<a.length;c++)R.call(e,a[c])&&o.push("["+t(a[c])+"]: "+t(e[a[c]],e));return o}}).call(this,r("c8ba"))},"2aa9":function(e,t,r){"use strict";var o=r("00ce"),n=o("%Object.getOwnPropertyDescriptor%",!0);if(n)try{n([],"length")}catch(i){n=null}e.exports=n},"3eb1":function(e,t,r){"use strict";var o=r("0f7c"),n=r("00ce"),i=r("d009"),a=r("0d25"),s=n("%Function.prototype.apply%"),l=n("%Function.prototype.call%"),c=n("%Reflect.apply%",!0)||o.call(l,s),u=r("71c9"),p=n("%Math.max%");e.exports=function(e){if("function"!==typeof e)throw new a("a function is required");var t=c(o,l,arguments);return i(t,1+p(0,e.length-(arguments.length-1)),!0)};var f=function(){return c(o,s,arguments)};u?u(e.exports,"apply",{value:f}):e.exports.apply=f},"417f":function(e,t,r){"use strict";e.exports=EvalError},4332:function(e,t,r){var o=r("b11f");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[e.i,o,""]]),o.locals&&(e.exports=o.locals);var n=r("499e").default;n("0883be1e",o,!0,{sourceMap:!1,shadowMode:!1})},5156:function(e,t,r){"use strict";var o="undefined"!==typeof Symbol&&Symbol,n=r("1696");e.exports=function(){return"function"===typeof o&&("function"===typeof Symbol&&("symbol"===typeof o("foo")&&("symbol"===typeof Symbol("bar")&&n())))}},5402:function(e,t,r){"use strict";var o=r("00ce"),n=r("545e"),i=r("2714"),a=r("0d25"),s=o("%WeakMap%",!0),l=o("%Map%",!0),c=n("WeakMap.prototype.get",!0),u=n("WeakMap.prototype.set",!0),p=n("WeakMap.prototype.has",!0),f=n("Map.prototype.get",!0),h=n("Map.prototype.set",!0),y=n("Map.prototype.has",!0),d=function(e,t){for(var r,o=e;null!==(r=o.next);o=r)if(r.key===t)return o.next=r.next,r.next=e.next,e.next=r,r},m=function(e,t){var r=d(e,t);return r&&r.value},g=function(e,t,r){var o=d(e,t);o?o.value=r:e.next={key:t,next:e.next,value:r}},b=function(e,t){return!!d(e,t)};e.exports=function(){var e,t,r,o={assert:function(e){if(!o.has(e))throw new a("Side channel does not contain "+i(e))},get:function(o){if(s&&o&&("object"===typeof o||"function"===typeof o)){if(e)return c(e,o)}else if(l){if(t)return f(t,o)}else if(r)return m(r,o)},has:function(o){if(s&&o&&("object"===typeof o||"function"===typeof o)){if(e)return p(e,o)}else if(l){if(t)return y(t,o)}else if(r)return b(r,o);return!1},set:function(o,n){s&&o&&("object"===typeof o||"function"===typeof o)?(e||(e=new s),u(e,o,n)):l?(t||(t=new l),h(t,o,n)):(r||(r={key:{},next:null}),g(r,o,n))}};return o}},"545e":function(e,t,r){"use strict";var o=r("00ce"),n=r("3eb1"),i=n(o("String.prototype.indexOf"));e.exports=function(e,t){var r=o(e,!!t);return"function"===typeof r&&i(e,".prototype.")>-1?n(r):r}},5748:function(e,t,r){"use strict";r.r(t);var o=function(){var e=this,t=e._self._c;return t("div",[t("meta",{attrs:{name:"viewport",content:"width=device-width, initial-scale=0.5, maximum-scale=0.5"}}),t("header",{staticClass:"controls"},[e.disableStore?e._e():t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{sessionKey:"lotus-profilerSourceText"},model:{value:e.sourceText,callback:function(t){e.sourceText=t},expression:"sourceText"}}),e.disableStore?e._e():t("BoolStoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{sessionKey:"lotus-profilerBakingSheet"},model:{value:e.bakingSheet,callback:function(t){e.bakingSheet=t},expression:"bakingSheet"}}),t("input",{attrs:{type:"file"},on:{change:e.onScoreChange}}),t("button",{on:{click:e.homePlayer}},[e._v("⏮")]),t("button",{attrs:{disabled:!e.midiPlayer},on:{click:e.togglePlayer}},[e._v(e._s(e.midiPlayer&&e.midiPlayer.isPlaying?"⏸":"▶"))]),t("CheckButton",{attrs:{content:"&#xa56f;"},model:{value:e.showCursor,callback:function(t){e.showCursor=t},expression:"showCursor"}}),t("CheckButton",{attrs:{content:"&#x2669;"},model:{value:e.noteHighlight,callback:function(t){e.noteHighlight=t},expression:"noteHighlight"}}),t("CheckButton",{attrs:{content:"&#x1f35e;"},model:{value:e.bakingSheet,callback:function(t){e.bakingSheet=t},expression:"bakingSheet"}}),e.fps?t("span",{staticClass:"fps"},[t("em",[e._v(e._s(e.fps.toFixed(1)))]),e._v("fps")]):e._e()],1),t("main",{on:{scroll:e.onScroll}},[!e.bakingSheet&&e.svgHashTable?t("SheetSigns",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],ref:"signs",attrs:{hashTable:e.svgHashTable}}):e._e(),e.sheetDocument?t("SheetLive",{ref:"sheet",attrs:{doc:e.sheetDocument,midiNotation:e.midiNotation,pitchContextGroup:e.pitchContextGroup,midiPlayer:e.midiPlayer,scheduler:e.scheduler,showCursor:e.showCursor,noteHighlight:e.noteHighlight,bakingMode:e.bakingSheet,backgroundImages:e.bakingSheet?e.bakingImages:null,showPagesProgressively:e.showPagesProgressively},on:{"update:midiPlayer":function(t){e.midiPlayer=t},"update:midi-player":function(t){e.midiPlayer=t},midi:e.onMidi}}):e._e()],1),t("canvas",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],ref:"canvas"})])},n=[],i=r("0b16"),a=r.n(i),s=r("b047"),l=r.n(s),c=(r("8701"),r("5027")),u=r("9224"),p=r("f634"),f=r("32c1"),h=r("1151"),y=r("a31e"),d=r("1c3a"),m=r("c0d2");const g=e=>{if(e){const t=e.match(/\d+/g);if(t){const e=t.map(Number).reverse();return e.reduce((e,t,r)=>e+t*1e3**r,0)}}return-1};class b{constructor({onStatus:e=((...e)=>e)}={}){this.onStatus=e}static fromJSON(e,{measureLayout:t=y["b"].Full,onStatus:r=((...e)=>e),jsonHandle:o=(e=>e)}={}){const n=new b({onStatus:r});return n.scoreJSON=o(Object(p["b"])(e,b.classDict)),n.checkVersion(),n.onStatus("json loaded"),n.scoreJSON.lilyNotation&&(n.matchedIds=n.scoreJSON.lilyNotation.idSet,n.scoreJSON.doc.updateMatchedTokens(n.matchedIds)),t&&n.loadNotation(t),n}loadNotation(e,t){const r=this.scoreJSON.lilyNotation;if(r){const o=r.getMeasureIndices(e);this.midiNotation=r.toPerformingNotationWithEvents(o,{trackList:t}),this.pitchContextGroup=r.getContextGroup(o);const n=r.toPerformingNotation(o,{withRestTied:!0});this.scheduler=y["e"].createFromNotation(n,this.scoreJSON.doc.getTokenMap()),this.onStatus("notation loaded")}}bakeSheet(e){return console.assert(!!this.scoreJSON.doc,"sheetDocument is null."),console.assert(!!this.scoreJSON.hashTable,"hashTable is null."),console.assert(!!this.matchedIds,"matchedIds is null."),this.onStatus("baking sheet"),d["a"]({sheetDocument:this.scoreJSON.doc,hashTable:this.scoreJSON.hashTable,matchedIds:this.matchedIds,canvas:e})}checkVersion(){const e=g(u.version),t=g(this.scoreJSON.version);t<g("0.6.1")&&console.warn(`This score bundle version[${this.scoreJSON.version}] is too low! The current Lotus API version is: ${u.version}.`),t>e&&console.warn(`The current Lotus API version[${u.version}] is behind this score bundle[${this.scoreJSON.version}]. If any score problem encountered, try to upgrade Lotus API.`),t>=0&&t<g("0.8.0")&&this.scoreJSON.doc.pages.forEach(e=>e.systems=e.rows)}}b.classDict={StaffToken:f["StaffToken"],SheetDocument:f["SheetDocument"],LilyNotation:y["d"],...y["c"],DictArray:m["a"],PitchContextTable:h["b"],PitchContext:h["a"]};var v=r("faa1");class w extends v["EventEmitter"]{constructor(e,{separator:t="\n\n\n\n"}={}){super(),this.reader=e,this.separator=t}async read(){let e="";while(1){const{done:t,value:r}=await this.reader.read();if(r){const t=new TextDecoder("utf-8").decode(r);e+=t;while(1){const t=e.indexOf(this.separator);if(!(t>=0))break;{const r=e.substr(0,t);this.emit("data",r),e=e.substr(t+this.separator.length)}}}if(t)break}e&&this.emit("data",e)}}var S=r("a139"),x=r("f7ce"),O=r("cdaf"),j=r("4e72"),A=r("ddcc"),P={name:"profiler",components:{SheetLive:S["a"],SheetSigns:x["a"],StoreInput:O["a"],BoolStoreInput:j["a"],CheckButton:A["a"]},data(){return{sourceText:null,sheetDocument:null,svgHashTable:null,midiNotation:null,scheduler:null,pitchContextGroup:null,midiPlayer:null,showCursor:!0,noteHighlight:!0,bakingSheet:!0,bakingImages:null,sourceBakingImages:null,fps:null,disableStore:!1,showPagesProgressively:!0}},async created(){this.logTime("created"),window.$main=this,this.watchFps();const e=a.a.parse(location.hash.substr(1),!0);e.query.score&&(this.disableStore=!0,this.loadScoreFromURL(e.query.score)),e.query.nobake&&(this.bakingSheet=!1)},methods:{logTime(e){console.log("[PROFILER]",e,performance.now())},onScoreChange(e){const t=e.target.files[0];if(t)return this.loadScoreFile(t)},onScroll:l()((function(){this.$refs.sheet.updatePageVisibility()}),60,{leading:!0}),async loadScoreFile(e){switch(this.logTime("file loading begin"),e.type){case"application/json":this.sourceText=await e.readAs("Text");break;case"application/zip":case"application/x-zip-compressed":{this.sourceText=null,await this.$nextTick();const{default:t}=await r.e("chunk-48b5b2a0").then(r.t.bind(null,"c4e3",7)),o=await t.loadAsync(e);this.sourceBakingImages=null;for(let e=0;1;++e){const t=o.file(`baking${e}.png`);if(!t)break;const r=await t.async("blob"),n=URL.createObjectURL(r);this.sourceBakingImages=this.sourceBakingImages||[],this.sourceBakingImages.push(n)}this.sourceBakingImages&&this.logTime(`baking images loaded [${this.sourceBakingImages.length}]`),this.sourceText=await o.file("score.json").async("text"),this.logTime("sourceText loaded.")}break;case"text/x-lilypond":case"text/lilypond-source":{const t=await e.readAs("Text"),r=new FormData;r.append("source",t),r.append("withLilyNotation",1);const o=await fetch("/advanced-engrave",{method:"POST",body:r});if(!o.ok)return this.error=await o.text(),void console.warn("advanced-engrave failed:",this.error);const n=new w(o.body.getReader());this.constructSheetFromStream(n)}break;default:console.log("unsupported type:",e.type)}},async loadScoreFromURL(e){this.logTime("URL fetching begin");const t=await fetch(e);if(!t.ok)return void console.warn("URL load failed:",await t.text());this.logTime("network responsed");const r=await t.blob();return this.loadScoreFile(r)},async loadSheet(){if(this.sheetDocument=null,this.midiNotation=null,this.scheduler=null,this.pitchContextGroup=null,this.bakingImages=null,this.sourceText){this.showPagesProgressively=!0;const e=b.fromJSON(this.sourceText,{onStatus:e=>this.logTime(e)});if(this.sheetDocument=e.scoreJSON.doc,this.pitchContextGroup=e.pitchContextGroup,this.midiNotation=e.midiNotation,this.scheduler=e.scheduler,this.svgHashTable=e.scoreJSON.hashTable,this.logTime("bundle parsed"),await this.$nextTick(),this.logTime("rendering initialized"),this.sourceBakingImages)this.bakingImages=this.sourceBakingImages,this.sourceBakingImages=null;else if(this.bakingSheet){this.bakingImages=[];const t=e.bakeSheet(this.$refs.canvas);this.logTime("baker loaded");for await(const e of t)this.bakingImages.push(e);this.logTime("baking finished")}await this.$nextTick(),this.logTime("rendering finished"),this.$refs.sheet.updatePageVisibility()}},async constructSheetFromStream(e){this.sheetDocument=null,this.midiNotation=null,this.scheduler=null,this.pitchContextGroup=null,this.bakingImages=null,this.svgHashTable={},this.showPagesProgressively=!1,this.bakingSheet=!1;const t=[];e.on("data",e=>{const r=Object(p["b"])(e,{...f,LilyNotation:y["d"],...y["c"]});if(console.log("data:",r),void 0!==r.page&&(t[r.page]=r.structure,this.svgHashTable={...this.svgHashTable,...r.hashTable},this.sheetDocument=new f["SheetDocument"]({pages:t})),r.lilyNotation){const e=r.lilyNotation,t=e.getMeasureIndices(y["b"].Full);this.midiNotation=e.toPerformingNotationWithEvents(t),this.pitchContextGroup=e.getContextGroup(t);const o=e.toPerformingNotation(t,{withRestTied:!0});this.scheduler=y["e"].createFromNotation(o,this.sheetDocument.getTokenMap())}}),await e.read()},onMidi(){},homePlayer(){this.midiPlayer&&this.midiPlayer.turnCursor(0)},togglePlayer(){this.midiPlayer&&(this.midiPlayer.isPlaying?this.midiPlayer.pause():this.midiPlayer.play())},async watchFps(){let e=performance.now(),t=0;while(1){await Object(c["a"])(),++t;const r=performance.now();r-e>1e3&&(this.fps=1e3*t/(r-e),t=0,e=r)}}},watch:{sourceText:"loadSheet"}},k=P,E=(r("ae16"),r("2877")),I=Object(E["a"])(k,o,n,!1,null,null,null);t["default"]=I.exports},"62e4":function(e,t){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children||(e.children=[]),Object.defineProperty(e,"loaded",{enumerable:!0,get:function(){return e.l}}),Object.defineProperty(e,"id",{enumerable:!0,get:function(){return e.i}}),e.webpackPolyfill=1),e}},"64b0":function(e,t,r){"use strict";var o=r("71c9"),n=function(){return!!o};n.hasArrayLengthDefineBug=function(){if(!o)return null;try{return 1!==o([],"length",{value:1}).length}catch(e){return!0}},e.exports=n},"67d9":function(e,t,r){"use strict";e.exports=URIError},"67ee":function(e,t,r){"use strict";e.exports=SyntaxError},"688e":function(e,t,r){"use strict";var o="Function.prototype.bind called on incompatible ",n=Object.prototype.toString,i=Math.max,a="[object Function]",s=function(e,t){for(var r=[],o=0;o<e.length;o+=1)r[o]=e[o];for(var n=0;n<t.length;n+=1)r[n+e.length]=t[n];return r},l=function(e,t){for(var r=[],o=t||0,n=0;o<e.length;o+=1,n+=1)r[n]=e[o];return r},c=function(e,t){for(var r="",o=0;o<e.length;o+=1)r+=e[o],o+1<e.length&&(r+=t);return r};e.exports=function(e){var t=this;if("function"!==typeof t||n.apply(t)!==a)throw new TypeError(o+t);for(var r,u=l(arguments,1),p=function(){if(this instanceof r){var o=t.apply(this,s(u,arguments));return Object(o)===o?o:this}return t.apply(e,s(u,arguments))},f=i(0,t.length-u.length),h=[],y=0;y<f;y++)h[y]="$"+y;if(r=Function("binder","return function ("+c(h,",")+"){ return binder.apply(this,arguments); }")(p),t.prototype){var d=function(){};d.prototype=t.prototype,r.prototype=new d,d.prototype=null}return r}},"71c9":function(e,t,r){"use strict";var o=r("00ce"),n=o("%Object.defineProperty%",!0)||!1;if(n)try{n({},"a",{value:1})}catch(i){n=!1}e.exports=n},7992:function(e,t,r){"use strict";var o=r("71c9"),n=r("67ee"),i=r("0d25"),a=r("2aa9");e.exports=function(e,t,r){if(!e||"object"!==typeof e&&"function"!==typeof e)throw new i("`obj` must be an object or a function`");if("string"!==typeof t&&"symbol"!==typeof t)throw new i("`property` must be a string or a symbol`");if(arguments.length>3&&"boolean"!==typeof arguments[3]&&null!==arguments[3])throw new i("`nonEnumerable`, if provided, must be a boolean or null");if(arguments.length>4&&"boolean"!==typeof arguments[4]&&null!==arguments[4])throw new i("`nonWritable`, if provided, must be a boolean or null");if(arguments.length>5&&"boolean"!==typeof arguments[5]&&null!==arguments[5])throw new i("`nonConfigurable`, if provided, must be a boolean or null");if(arguments.length>6&&"boolean"!==typeof arguments[6])throw new i("`loose`, if provided, must be a boolean");var s=arguments.length>3?arguments[3]:null,l=arguments.length>4?arguments[4]:null,c=arguments.length>5?arguments[5]:null,u=arguments.length>6&&arguments[6],p=!!a&&a(e,t);if(o)o(e,t,{configurable:null===c&&p?p.configurable:!c,enumerable:null===s&&p?p.enumerable:!s,value:r,writable:null===l&&p?p.writable:!l});else{if(!u&&(s||l||c))throw new n("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");e[t]=r}}},9671:function(e,t,r){"use strict";var o=Function.prototype.call,n=Object.prototype.hasOwnProperty,i=r("0f7c");e.exports=i.call(o,n)},"9d88":function(e,t,r){(function(e,o){var n;/*! https://mths.be/punycode v1.4.1 by @mathias */(function(i){t&&t.nodeType,e&&e.nodeType;var a="object"==typeof o&&o;a.global!==a&&a.window!==a&&a.self;var s,l=2147483647,c=36,u=1,p=26,f=38,h=700,y=72,d=128,m="-",g=/^xn--/,b=/[^\x20-\x7E]/,v=/[\x2E\u3002\uFF0E\uFF61]/g,w={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},S=c-u,x=Math.floor,O=String.fromCharCode;function j(e){throw new RangeError(w[e])}function A(e,t){var r=e.length,o=[];while(r--)o[r]=t(e[r]);return o}function P(e,t){var r=e.split("@"),o="";r.length>1&&(o=r[0]+"@",e=r[1]),e=e.replace(v,".");var n=e.split("."),i=A(n,t).join(".");return o+i}function k(e){var t,r,o=[],n=0,i=e.length;while(n<i)t=e.charCodeAt(n++),t>=55296&&t<=56319&&n<i?(r=e.charCodeAt(n++),56320==(64512&r)?o.push(((1023&t)<<10)+(1023&r)+65536):(o.push(t),n--)):o.push(t);return o}function E(e){return A(e,(function(e){var t="";return e>65535&&(e-=65536,t+=O(e>>>10&1023|55296),e=56320|1023&e),t+=O(e),t})).join("")}function I(e){return e-48<10?e-22:e-65<26?e-65:e-97<26?e-97:c}function _(e,t){return e+22+75*(e<26)-((0!=t)<<5)}function T(e,t,r){var o=0;for(e=r?x(e/h):e>>1,e+=x(e/t);e>S*p>>1;o+=c)e=x(e/S);return x(o+(S+1)*e/(e+f))}function N(e){var t,r,o,n,i,a,s,f,h,g,b=[],v=e.length,w=0,S=d,O=y;for(r=e.lastIndexOf(m),r<0&&(r=0),o=0;o<r;++o)e.charCodeAt(o)>=128&&j("not-basic"),b.push(e.charCodeAt(o));for(n=r>0?r+1:0;n<v;){for(i=w,a=1,s=c;;s+=c){if(n>=v&&j("invalid-input"),f=I(e.charCodeAt(n++)),(f>=c||f>x((l-w)/a))&&j("overflow"),w+=f*a,h=s<=O?u:s>=O+p?p:s-O,f<h)break;g=c-h,a>x(l/g)&&j("overflow"),a*=g}t=b.length+1,O=T(w-i,t,0==i),x(w/t)>l-S&&j("overflow"),S+=x(w/t),w%=t,b.splice(w++,0,S)}return E(b)}function C(e){var t,r,o,n,i,a,s,f,h,g,b,v,w,S,A,P=[];for(e=k(e),v=e.length,t=d,r=0,i=y,a=0;a<v;++a)b=e[a],b<128&&P.push(O(b));o=n=P.length,n&&P.push(m);while(o<v){for(s=l,a=0;a<v;++a)b=e[a],b>=t&&b<s&&(s=b);for(w=o+1,s-t>x((l-r)/w)&&j("overflow"),r+=(s-t)*w,t=s,a=0;a<v;++a)if(b=e[a],b<t&&++r>l&&j("overflow"),b==t){for(f=r,h=c;;h+=c){if(g=h<=i?u:h>=i+p?p:h-i,f<g)break;A=f-g,S=c-g,P.push(O(_(g+A%S,0))),f=x(A/S)}P.push(O(_(f,0))),i=T(r,w,o==n),r=0,++o}++r,++t}return P.join("")}function F(e){return P(e,(function(e){return g.test(e)?N(e.slice(4).toLowerCase()):e}))}function R(e){return P(e,(function(e){return b.test(e)?"xn--"+C(e):e}))}s={version:"1.4.1",ucs2:{decode:k,encode:E},decode:N,encode:C,toASCII:R,toUnicode:F},n=function(){return s}.call(t,r,t,e),void 0===n||(e.exports=n)})()}).call(this,r("62e4")(e),r("c8ba"))},a29f:function(e,t,r){"use strict";var o=r("bbc7"),n=Object.prototype.hasOwnProperty,i=Array.isArray,a=function(){for(var e=[],t=0;t<256;++t)e.push("%"+((t<16?"0":"")+t.toString(16)).toUpperCase());return e}(),s=function(e){while(e.length>1){var t=e.pop(),r=t.obj[t.prop];if(i(r)){for(var o=[],n=0;n<r.length;++n)"undefined"!==typeof r[n]&&o.push(r[n]);t.obj[t.prop]=o}}},l=function(e,t){for(var r=t&&t.plainObjects?{__proto__:null}:{},o=0;o<e.length;++o)"undefined"!==typeof e[o]&&(r[o]=e[o]);return r},c=function e(t,r,o){if(!r)return t;if("object"!==typeof r&&"function"!==typeof r){if(i(t))t.push(r);else{if(!t||"object"!==typeof t)return[t,r];(o&&(o.plainObjects||o.allowPrototypes)||!n.call(Object.prototype,r))&&(t[r]=!0)}return t}if(!t||"object"!==typeof t)return[t].concat(r);var a=t;return i(t)&&!i(r)&&(a=l(t,o)),i(t)&&i(r)?(r.forEach((function(r,i){if(n.call(t,i)){var a=t[i];a&&"object"===typeof a&&r&&"object"===typeof r?t[i]=e(a,r,o):t.push(r)}else t[i]=r})),t):Object.keys(r).reduce((function(t,i){var a=r[i];return n.call(t,i)?t[i]=e(t[i],a,o):t[i]=a,t}),a)},u=function(e,t){return Object.keys(t).reduce((function(e,r){return e[r]=t[r],e}),e)},p=function(e,t,r){var o=e.replace(/\+/g," ");if("iso-8859-1"===r)return o.replace(/%[0-9a-f]{2}/gi,unescape);try{return decodeURIComponent(o)}catch(n){return o}},f=1024,h=function(e,t,r,n,i){if(0===e.length)return e;var s=e;if("symbol"===typeof e?s=Symbol.prototype.toString.call(e):"string"!==typeof e&&(s=String(e)),"iso-8859-1"===r)return escape(s).replace(/%u[0-9a-f]{4}/gi,(function(e){return"%26%23"+parseInt(e.slice(2),16)+"%3B"}));for(var l="",c=0;c<s.length;c+=f){for(var u=s.length>=f?s.slice(c,c+f):s,p=[],h=0;h<u.length;++h){var y=u.charCodeAt(h);45===y||46===y||95===y||126===y||y>=48&&y<=57||y>=65&&y<=90||y>=97&&y<=122||i===o.RFC1738&&(40===y||41===y)?p[p.length]=u.charAt(h):y<128?p[p.length]=a[y]:y<2048?p[p.length]=a[192|y>>6]+a[128|63&y]:y<55296||y>=57344?p[p.length]=a[224|y>>12]+a[128|y>>6&63]+a[128|63&y]:(h+=1,y=65536+((1023&y)<<10|1023&u.charCodeAt(h)),p[p.length]=a[240|y>>18]+a[128|y>>12&63]+a[128|y>>6&63]+a[128|63&y])}l+=p.join("")}return l},y=function(e){for(var t=[{obj:{o:e},prop:"o"}],r=[],o=0;o<t.length;++o)for(var n=t[o],i=n.obj[n.prop],a=Object.keys(i),l=0;l<a.length;++l){var c=a[l],u=i[c];"object"===typeof u&&null!==u&&-1===r.indexOf(u)&&(t.push({obj:i,prop:c}),r.push(u))}return s(t),e},d=function(e){return"[object RegExp]"===Object.prototype.toString.call(e)},m=function(e){return!(!e||"object"!==typeof e)&&!!(e.constructor&&e.constructor.isBuffer&&e.constructor.isBuffer(e))},g=function(e,t){return[].concat(e,t)},b=function(e,t){if(i(e)){for(var r=[],o=0;o<e.length;o+=1)r.push(t(e[o]));return r}return t(e)};e.exports={arrayToObject:l,assign:u,combine:g,compact:y,decode:p,encode:h,isBuffer:m,isRegExp:d,maybeMap:b,merge:c}},a645:function(e,t,r){"use strict";e.exports=Error},ae16:function(e,t,r){"use strict";r("4332")},b11f:function(e,t,r){var o=r("24fb");t=o(!1),t.push([e.i,'button.working{background-color:#dfd;font-weight:700}button.on{background-color:#efe;font-weight:700;box-shadow:0 0 4px #000}button.off{opacity:.7;filter:grayscale(100%)}button[disabled]{box-shadow:none;cursor:not-allowed!important}.controls fieldset{border:0;padding:0 1em}.controls fieldset,.controls fieldset>span{display:inline-block}.controls fieldset>*{margin:0 .2em}.controls>*,.controls fieldset>*{vertical-align:middle}header.controls{padding:1em;text-align:center;background-color:hsla(0,0%,100%,.6666666666666666)}header.controls button{font-size:24px}header.controls .dirty-badge{width:1em}header.controls .dirty-badge.dirty:before{content:"*"}header .fps{display:inline-block;margin:0 1em;color:#aaa}header .fps em{color:#000;display:inline-block;margin:0 .2em}main{width:100%;overflow:auto}main .sheet.live{white-space:nowrap;display:inline-block}main .sheet.live .page{display:inline-block;margin:1em;background-size:100%}main .sheet.live .cursor{fill:#add8e6}',""]),e.exports=t},bbc7:function(e,t,r){"use strict";var o=String.prototype.replace,n=/%20/g,i={RFC1738:"RFC1738",RFC3986:"RFC3986"};e.exports={default:i.RFC3986,formatters:{RFC1738:function(e){return o.call(e,n,"+")},RFC3986:function(e){return String(e)}},RFC1738:i.RFC1738,RFC3986:i.RFC3986}},d009:function(e,t,r){"use strict";var o=r("00ce"),n=r("7992"),i=r("64b0")(),a=r("2aa9"),s=r("0d25"),l=o("%Math.floor%");e.exports=function(e,t){if("function"!==typeof e)throw new s("`fn` is not a function");if("number"!==typeof t||t<0||t>4294967295||l(t)!==t)throw new s("`length` must be a positive 32-bit integer");var r=arguments.length>2&&!!arguments[2],o=!0,c=!0;if("length"in e&&a){var u=a(e,"length");u&&!u.configurable&&(o=!1),u&&!u.writable&&(c=!1)}return(o||c||!r)&&(i?n(e,"length",t,!0,!0):n(e,"length",t)),e}},dc99:function(e,t,r){"use strict";e.exports=RangeError},f177:function(e,t,r){"use strict";var o=r("5402"),n=r("a29f"),i=r("bbc7"),a=Object.prototype.hasOwnProperty,s={brackets:function(e){return e+"[]"},comma:"comma",indices:function(e,t){return e+"["+t+"]"},repeat:function(e){return e}},l=Array.isArray,c=Array.prototype.push,u=function(e,t){c.apply(e,l(t)?t:[t])},p=Date.prototype.toISOString,f=i["default"],h={addQueryPrefix:!1,allowDots:!1,allowEmptyArrays:!1,arrayFormat:"indices",charset:"utf-8",charsetSentinel:!1,commaRoundTrip:!1,delimiter:"&",encode:!0,encodeDotInKeys:!1,encoder:n.encode,encodeValuesOnly:!1,filter:void 0,format:f,formatter:i.formatters[f],indices:!1,serializeDate:function(e){return p.call(e)},skipNulls:!1,strictNullHandling:!1},y=function(e){return"string"===typeof e||"number"===typeof e||"boolean"===typeof e||"symbol"===typeof e||"bigint"===typeof e},d={},m=function e(t,r,i,a,s,c,p,f,m,g,b,v,w,S,x,O,j,A){var P=t,k=A,E=0,I=!1;while(void 0!==(k=k.get(d))&&!I){var _=k.get(t);if(E+=1,"undefined"!==typeof _){if(_===E)throw new RangeError("Cyclic object value");I=!0}"undefined"===typeof k.get(d)&&(E=0)}if("function"===typeof g?P=g(r,P):P instanceof Date?P=w(P):"comma"===i&&l(P)&&(P=n.maybeMap(P,(function(e){return e instanceof Date?w(e):e}))),null===P){if(c)return m&&!O?m(r,h.encoder,j,"key",S):r;P=""}if(y(P)||n.isBuffer(P)){if(m){var T=O?r:m(r,h.encoder,j,"key",S);return[x(T)+"="+x(m(P,h.encoder,j,"value",S))]}return[x(r)+"="+x(String(P))]}var N,C=[];if("undefined"===typeof P)return C;if("comma"===i&&l(P))O&&m&&(P=n.maybeMap(P,m)),N=[{value:P.length>0?P.join(",")||null:void 0}];else if(l(g))N=g;else{var F=Object.keys(P);N=b?F.sort(b):F}var R=f?String(r).replace(/\./g,"%2E"):String(r),L=a&&l(P)&&1===P.length?R+"[]":R;if(s&&l(P)&&0===P.length)return L+"[]";for(var D=0;D<N.length;++D){var M=N[D],U="object"===typeof M&&M&&"undefined"!==typeof M.value?M.value:P[M];if(!p||null!==U){var B=v&&f?String(M).replace(/\./g,"%2E"):String(M),W=l(P)?"function"===typeof i?i(L,B):L:L+(v?"."+B:"["+B+"]");A.set(t,E);var q=o();q.set(d,A),u(C,e(U,W,i,a,s,c,p,f,"comma"===i&&O&&l(P)?null:m,g,b,v,w,S,x,O,j,q))}}return C},g=function(e){if(!e)return h;if("undefined"!==typeof e.allowEmptyArrays&&"boolean"!==typeof e.allowEmptyArrays)throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");if("undefined"!==typeof e.encodeDotInKeys&&"boolean"!==typeof e.encodeDotInKeys)throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");if(null!==e.encoder&&"undefined"!==typeof e.encoder&&"function"!==typeof e.encoder)throw new TypeError("Encoder has to be a function.");var t=e.charset||h.charset;if("undefined"!==typeof e.charset&&"utf-8"!==e.charset&&"iso-8859-1"!==e.charset)throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");var r=i["default"];if("undefined"!==typeof e.format){if(!a.call(i.formatters,e.format))throw new TypeError("Unknown format option provided.");r=e.format}var o,n=i.formatters[r],c=h.filter;if(("function"===typeof e.filter||l(e.filter))&&(c=e.filter),o=e.arrayFormat in s?e.arrayFormat:"indices"in e?e.indices?"indices":"repeat":h.arrayFormat,"commaRoundTrip"in e&&"boolean"!==typeof e.commaRoundTrip)throw new TypeError("`commaRoundTrip` must be a boolean, or absent");var u="undefined"===typeof e.allowDots?!0===e.encodeDotInKeys||h.allowDots:!!e.allowDots;return{addQueryPrefix:"boolean"===typeof e.addQueryPrefix?e.addQueryPrefix:h.addQueryPrefix,allowDots:u,allowEmptyArrays:"boolean"===typeof e.allowEmptyArrays?!!e.allowEmptyArrays:h.allowEmptyArrays,arrayFormat:o,charset:t,charsetSentinel:"boolean"===typeof e.charsetSentinel?e.charsetSentinel:h.charsetSentinel,commaRoundTrip:!!e.commaRoundTrip,delimiter:"undefined"===typeof e.delimiter?h.delimiter:e.delimiter,encode:"boolean"===typeof e.encode?e.encode:h.encode,encodeDotInKeys:"boolean"===typeof e.encodeDotInKeys?e.encodeDotInKeys:h.encodeDotInKeys,encoder:"function"===typeof e.encoder?e.encoder:h.encoder,encodeValuesOnly:"boolean"===typeof e.encodeValuesOnly?e.encodeValuesOnly:h.encodeValuesOnly,filter:c,format:r,formatter:n,serializeDate:"function"===typeof e.serializeDate?e.serializeDate:h.serializeDate,skipNulls:"boolean"===typeof e.skipNulls?e.skipNulls:h.skipNulls,sort:"function"===typeof e.sort?e.sort:null,strictNullHandling:"boolean"===typeof e.strictNullHandling?e.strictNullHandling:h.strictNullHandling}};e.exports=function(e,t){var r,n,i=e,a=g(t);"function"===typeof a.filter?(n=a.filter,i=n("",i)):l(a.filter)&&(n=a.filter,r=n);var c=[];if("object"!==typeof i||null===i)return"";var p=s[a.arrayFormat],f="comma"===p&&a.commaRoundTrip;r||(r=Object.keys(i)),a.sort&&r.sort(a.sort);for(var h=o(),y=0;y<r.length;++y){var d=r[y],b=i[d];a.skipNulls&&null===b||u(c,m(b,d,p,f,a.allowEmptyArrays,a.strictNullHandling,a.skipNulls,a.encodeDotInKeys,a.encode?a.encoder:null,a.filter,a.sort,a.allowDots,a.serializeDate,a.format,a.formatter,a.encodeValuesOnly,a.charset,h))}var v=c.join(a.delimiter),w=!0===a.addQueryPrefix?"?":"";return a.charsetSentinel&&("iso-8859-1"===a.charset?w+="utf8=%26%2310003%3B&":w+="utf8=%E2%9C%93&"),v.length>0?w+v:""}},faa1:function(e,t,r){"use strict";var o,n="object"===typeof Reflect?Reflect:null,i=n&&"function"===typeof n.apply?n.apply:function(e,t,r){return Function.prototype.apply.call(e,t,r)};function a(e){console&&console.warn&&console.warn(e)}o=n&&"function"===typeof n.ownKeys?n.ownKeys:Object.getOwnPropertySymbols?function(e){return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e))}:function(e){return Object.getOwnPropertyNames(e)};var s=Number.isNaN||function(e){return e!==e};function l(){l.init.call(this)}e.exports=l,e.exports.once=w,l.EventEmitter=l,l.prototype._events=void 0,l.prototype._eventsCount=0,l.prototype._maxListeners=void 0;var c=10;function u(e){if("function"!==typeof e)throw new TypeError('The "listener" argument must be of type Function. Received type '+typeof e)}function p(e){return void 0===e._maxListeners?l.defaultMaxListeners:e._maxListeners}function f(e,t,r,o){var n,i,s;if(u(r),i=e._events,void 0===i?(i=e._events=Object.create(null),e._eventsCount=0):(void 0!==i.newListener&&(e.emit("newListener",t,r.listener?r.listener:r),i=e._events),s=i[t]),void 0===s)s=i[t]=r,++e._eventsCount;else if("function"===typeof s?s=i[t]=o?[r,s]:[s,r]:o?s.unshift(r):s.push(r),n=p(e),n>0&&s.length>n&&!s.warned){s.warned=!0;var l=new Error("Possible EventEmitter memory leak detected. "+s.length+" "+String(t)+" listeners added. Use emitter.setMaxListeners() to increase limit");l.name="MaxListenersExceededWarning",l.emitter=e,l.type=t,l.count=s.length,a(l)}return e}function h(){if(!this.fired)return this.target.removeListener(this.type,this.wrapFn),this.fired=!0,0===arguments.length?this.listener.call(this.target):this.listener.apply(this.target,arguments)}function y(e,t,r){var o={fired:!1,wrapFn:void 0,target:e,type:t,listener:r},n=h.bind(o);return n.listener=r,o.wrapFn=n,n}function d(e,t,r){var o=e._events;if(void 0===o)return[];var n=o[t];return void 0===n?[]:"function"===typeof n?r?[n.listener||n]:[n]:r?v(n):g(n,n.length)}function m(e){var t=this._events;if(void 0!==t){var r=t[e];if("function"===typeof r)return 1;if(void 0!==r)return r.length}return 0}function g(e,t){for(var r=new Array(t),o=0;o<t;++o)r[o]=e[o];return r}function b(e,t){for(;t+1<e.length;t++)e[t]=e[t+1];e.pop()}function v(e){for(var t=new Array(e.length),r=0;r<t.length;++r)t[r]=e[r].listener||e[r];return t}function w(e,t){return new Promise((function(r,o){function n(r){e.removeListener(t,i),o(r)}function i(){"function"===typeof e.removeListener&&e.removeListener("error",n),r([].slice.call(arguments))}x(e,t,i,{once:!0}),"error"!==t&&S(e,n,{once:!0})}))}function S(e,t,r){"function"===typeof e.on&&x(e,"error",t,r)}function x(e,t,r,o){if("function"===typeof e.on)o.once?e.once(t,r):e.on(t,r);else{if("function"!==typeof e.addEventListener)throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type '+typeof e);e.addEventListener(t,(function n(i){o.once&&e.removeEventListener(t,n),r(i)}))}}Object.defineProperty(l,"defaultMaxListeners",{enumerable:!0,get:function(){return c},set:function(e){if("number"!==typeof e||e<0||s(e))throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received '+e+".");c=e}}),l.init=function(){void 0!==this._events&&this._events!==Object.getPrototypeOf(this)._events||(this._events=Object.create(null),this._eventsCount=0),this._maxListeners=this._maxListeners||void 0},l.prototype.setMaxListeners=function(e){if("number"!==typeof e||e<0||s(e))throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received '+e+".");return this._maxListeners=e,this},l.prototype.getMaxListeners=function(){return p(this)},l.prototype.emit=function(e){for(var t=[],r=1;r<arguments.length;r++)t.push(arguments[r]);var o="error"===e,n=this._events;if(void 0!==n)o=o&&void 0===n.error;else if(!o)return!1;if(o){var a;if(t.length>0&&(a=t[0]),a instanceof Error)throw a;var s=new Error("Unhandled error."+(a?" ("+a.message+")":""));throw s.context=a,s}var l=n[e];if(void 0===l)return!1;if("function"===typeof l)i(l,this,t);else{var c=l.length,u=g(l,c);for(r=0;r<c;++r)i(u[r],this,t)}return!0},l.prototype.addListener=function(e,t){return f(this,e,t,!1)},l.prototype.on=l.prototype.addListener,l.prototype.prependListener=function(e,t){return f(this,e,t,!0)},l.prototype.once=function(e,t){return u(t),this.on(e,y(this,e,t)),this},l.prototype.prependOnceListener=function(e,t){return u(t),this.prependListener(e,y(this,e,t)),this},l.prototype.removeListener=function(e,t){var r,o,n,i,a;if(u(t),o=this._events,void 0===o)return this;if(r=o[e],void 0===r)return this;if(r===t||r.listener===t)0===--this._eventsCount?this._events=Object.create(null):(delete o[e],o.removeListener&&this.emit("removeListener",e,r.listener||t));else if("function"!==typeof r){for(n=-1,i=r.length-1;i>=0;i--)if(r[i]===t||r[i].listener===t){a=r[i].listener,n=i;break}if(n<0)return this;0===n?r.shift():b(r,n),1===r.length&&(o[e]=r[0]),void 0!==o.removeListener&&this.emit("removeListener",e,a||t)}return this},l.prototype.off=l.prototype.removeListener,l.prototype.removeAllListeners=function(e){var t,r,o;if(r=this._events,void 0===r)return this;if(void 0===r.removeListener)return 0===arguments.length?(this._events=Object.create(null),this._eventsCount=0):void 0!==r[e]&&(0===--this._eventsCount?this._events=Object.create(null):delete r[e]),this;if(0===arguments.length){var n,i=Object.keys(r);for(o=0;o<i.length;++o)n=i[o],"removeListener"!==n&&this.removeAllListeners(n);return this.removeAllListeners("removeListener"),this._events=Object.create(null),this._eventsCount=0,this}if(t=r[e],"function"===typeof t)this.removeListener(e,t);else if(void 0!==t)for(o=t.length-1;o>=0;o--)this.removeListener(e,t[o]);return this},l.prototype.listeners=function(e){return d(this,e,!0)},l.prototype.rawListeners=function(e){return d(this,e,!1)},l.listenerCount=function(e,t){return"function"===typeof e.listenerCount?e.listenerCount(t):m.call(e,t)},l.prototype.listenerCount=m,l.prototype.eventNames=function(){return this._eventsCount>0?o(this._events):[]}}}]);
+//# sourceMappingURL=chunk-0cbfe13e.73856287.js.map

dist/js/chunk-117382e0.d47336d3.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-117382e0"],{"1e1a":function(e,t,a){"use strict";a("6b05")},"326e":function(e,t,a){var i=a("24fb");t=i(!1),t.push([e.i,".flex-engraver{width:100%;height:100vh}.flex-engraver header{position:absolute;width:100%;height:200px;background:#fafafa;display:flex;flex-direction:row;align-items:center;font-size:36px;overflow:hidden}.flex-engraver header>*{display:inline-block;font-size:inherit;margin:0 .5em}.flex-engraver header .source-list{min-width:8em}.flex-engraver header .gauge-view{height:100%}.flex-engraver header .dirty{font-weight:700;color:orange;cursor:pointer}.flex-engraver main{padding-top:200px;height:100%;background:#eee;white-space:nowrap}.flex-engraver main em{font-weight:700}.flex-engraver main .source-editor{height:calc(100% - 200px);vertical-align:top}.flex-engraver main .viewer{display:inline-block;position:relative;font-size:36px}.flex-engraver main .viewer .sheet-container{display:inline-block;resize:both;margin:2em;outline:1px solid #ccc;overflow:scroll;background:#fff}.flex-engraver main .viewer .sheet-container .sheet .page{margin:0}.flex-engraver main .viewer .sheet-container .loading-dots{background-color:transparent}.flex-engraver main .viewer .sheet-container .loading-dots .ellipsis{zoom:200%}.flex-engraver main .viewer .sheet-container .loading-dots .ellipsis>div{background-color:#4682b4}.flex-engraver main .viewer .container-size{display:inline-block;position:absolute;bottom:0;right:2em}.flex-engraver main .viewer .staff-size{display:inline-block;position:absolute;bottom:0;left:2em}.flex-engraver main .viewer .staff-size input{font-size:inherit}.flex-engraver main .viewer .staff-size .fit-staff-size{border:0}.flex-engraver main .viewer .staff-size .adjuster{display:inline-block;position:relative;margin:0 .6em;zoom:1.5}.flex-engraver main .viewer .staff-size .adjuster .slider{width:200px}.flex-engraver main .viewer .staff-size .adjuster .max,.flex-engraver main .viewer .staff-size .adjuster .min{display:inline-block;position:absolute;font-size:16px;top:3em;text-align:center}.flex-engraver main .viewer .staff-size .adjuster .max input,.flex-engraver main .viewer .staff-size .adjuster .min input{width:2em}.flex-engraver main .viewer .staff-size .adjuster .max .sheet,.flex-engraver main .viewer .staff-size .adjuster .min .sheet{position:absolute;top:120%;left:50%;transform:translate(-50%)}.flex-engraver main .viewer .staff-size .adjuster .min{left:0}.flex-engraver main .viewer .staff-size .adjuster .max{right:-2em}.flex-engraver main .staff-size-viewer{position:absolute;right:0;bottom:0}.flex-engraver main .staff-size-viewer input{width:4em}.flex-engraver.drag-hover header{background-color:#cfc;outline:4px dashed #4f4}",""]),e.exports=t},"6b05":function(e,t,a){var i=a("326e");i.__esModule&&(i=i.default),"string"===typeof i&&(i=[[e.i,i,""]]),i.locals&&(e.exports=i.locals);var n=a("499e").default;n("44bd81af",i,!0,{sourceMap:!1,shadowMode:!1})},e168:function(e,t,a){"use strict";a.r(t);var i=function(){var e=this,t=e._self._c;return t("div",{staticClass:"flex-engraver",class:{"drag-hover":e.dragHover},on:{dragover:function(t){t.preventDefault(),e.dragHover=!0},dragleave:function(t){e.dragHover=!1},drop:function(t){return t.preventDefault(),e.onDropFile.apply(null,arguments)}}},[t("header",[t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverContainerWidth"},model:{value:e.containerSize.offsetWidth,callback:function(t){e.$set(e.containerSize,"offsetWidth",t)},expression:"containerSize.offsetWidth"}}),t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverContainerHeight"},model:{value:e.containerSize.offsetHeight,callback:function(t){e.$set(e.containerSize,"offsetHeight",t)},expression:"containerSize.offsetHeight"}}),t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverChosenSourceIndex"},model:{value:e.chosenSourceIndex,callback:function(t){e.chosenSourceIndex=t},expression:"chosenSourceIndex"}}),t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverStaffSizeRangeMin"},model:{value:e.staffSizeRange.min,callback:function(t){e.$set(e.staffSizeRange,"min",t)},expression:"staffSizeRange.min"}}),t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverStaffSizeRangeMaX"},model:{value:e.staffSizeRange.max,callback:function(t){e.$set(e.staffSizeRange,"max",t)},expression:"staffSizeRange.max"}}),t("StoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverFitStaffSize"},model:{value:e.fitStaffSize,callback:function(t){e.fitStaffSize=t},expression:"fitStaffSize"}}),t("BoolStoreInput",{directives:[{name:"show",rawName:"v-show",value:!1,expression:"false"}],attrs:{localKey:"lotus-flexEngraverFixStaffSize"},model:{value:e.fixStaffSize,callback:function(t){e.fixStaffSize=t},expression:"fixStaffSize"}}),t("select",{directives:[{name:"model",rawName:"v-model",value:e.chosenSourceIndex,expression:"chosenSourceIndex"}],staticClass:"source-list",on:{change:function(t){var a=Array.prototype.filter.call(t.target.options,(function(e){return e.selected})).map((function(e){var t="_value"in e?e._value:e.value;return t}));e.chosenSourceIndex=t.target.multiple?a:a[0]}}},e._l(e.sourceList,(function(a,i){return t("option",{key:i,domProps:{value:i}},[e._v(e._s(a.name))])})),0),t("span",{staticClass:"dirty",on:{click:e.saveSource}},[e._v(e._s(e.sourceDirty?"*":" "))]),t("button",{on:{click:e.removeCurrentSource}},[e._v("🗑")]),t("button",{on:{click:e.gauge}},[e._v("📏")]),t("button",{on:{click:e.renderSheet}},[e._v("🎼")]),t("button",{attrs:{title:"copy lilypond source"},on:{click:e.copySource}},[e._v("⎘")]),t("button",{attrs:{title:"export scores json"},on:{click:e.exportSourceList}},[e._v("⤓")]),e.gaugeSvgDoc?t("div",{staticClass:"gauge-view"},[e.gaugeSvgDoc?t("SheetSimple",{attrs:{documents:[e.gaugeSvgDoc]}}):e._e()],1):e._e()],1),t("main",[e.currentSource?t("SourceEditor",{attrs:{source:e.currentSource.content},on:{"update:source":function(t){return e.$set(e.currentSource,"content",t)}}}):e._e(),t("div",{staticClass:"viewer"},[t("div",{ref:"sheetContainer",staticClass:"sheet-container",style:{width:e.containerSize.offsetWidth+"px",height:e.containerSize.offsetHeight+"px"},on:{mousemove:e.updateContainerSize}},[e.containerSvgs?t("SheetSimple",{attrs:{documents:e.containerSvgs}}):e._e(),t("Loading",{directives:[{name:"show",rawName:"v-show",value:e.containerEngraving,expression:"containerEngraving"}]})],1),t("div",{staticClass:"container-size"},[t("span",[e._v(e._s(e.containerSize.width))]),e._v(" × "),t("span",[e._v(e._s(e.containerSize.height))])]),e.fitStaffSize?t("div",{staticClass:"staff-size"},[t("em",[e._v(e._s(e.fitStaffSize.toFixed(2)))]),e._v(" pt "),t("span",{staticClass:"adjuster"},[t("input",{directives:[{name:"model",rawName:"v-model",value:e.fixStaffSize,expression:"fixStaffSize"}],attrs:{type:"checkbox",title:"fix staff size"},domProps:{checked:Array.isArray(e.fixStaffSize)?e._i(e.fixStaffSize,null)>-1:e.fixStaffSize},on:{change:function(t){var a=e.fixStaffSize,i=t.target,n=!!i.checked;if(Array.isArray(a)){var r=null,s=e._i(a,r);i.checked?s<0&&(e.fixStaffSize=a.concat([r])):s>-1&&(e.fixStaffSize=a.slice(0,s).concat(a.slice(s+1)))}else e.fixStaffSize=n}}}),t("input",{directives:[{name:"model",rawName:"v-model.number",value:e.fitStaffSize,expression:"fitStaffSize",modifiers:{number:!0}}],staticClass:"slider",attrs:{type:"range",disabled:!e.fixStaffSize,min:e.staffSizeRange.min,max:e.staffSizeRange.max,step:"any"},domProps:{value:e.fitStaffSize},on:{change:e.delayRenderSheet,__r:function(t){e.fitStaffSize=e._n(t.target.value)},blur:function(t){return e.$forceUpdate()}}}),t("span",{staticClass:"min"},[t("input",{directives:[{name:"model",rawName:"v-model",value:e.staffSizeRange.min,expression:"staffSizeRange.min"}],attrs:{type:"number"},domProps:{value:e.staffSizeRange.min},on:{change:e.updateStaffSampleMin,input:function(t){t.target.composing||e.$set(e.staffSizeRange,"min",t.target.value)}}}),e.staffSampleSvgMin?t("SheetSimple",{attrs:{documents:[e.staffSampleSvgMin]}}):e._e()],1),t("span",{staticClass:"max"},[t("input",{directives:[{name:"model",rawName:"v-model",value:e.staffSizeRange.max,expression:"staffSizeRange.max"}],attrs:{type:"number"},domProps:{value:e.staffSizeRange.max},on:{change:e.updateStaffSampleMax,input:function(t){t.target.composing||e.$set(e.staffSizeRange,"max",t.target.value)}}}),e.staffSampleSvgMax?t("SheetSimple",{attrs:{documents:[e.staffSampleSvgMax]}}):e._e()],1)])]):e._e()])],1)])},n=[],r=a("8701"),s=a("5027"),o=a("010e"),c=a("bc9f"),l=a("f634"),f=a("32c1"),u=a("1f25"),h=a("3122"),g=a("cdaf"),S=a("4e72"),d=a("94c1"),v=a("488d");const m=e=>`\n\t\t#(set-global-staff-size ${e})\n\t\t\\paper {\n\t\t\tpaper-width = ${.16*e}\\cm\n\t\t\tpaper-height = ${.08*e}\\cm\n\t\t\ttop-margin = 0\n\t\t\tbottom-margin = 0\n\t\t\tleft-margin = 0.2\\cm\n\t\t\tright-margin = 0\n\t\t}\n\t\t\\layout\n\t\t{\n\t\t\tindent = 0\n\t\t}\n\t\t{c'1}\n\t`,p=e=>e.replace(/(?:>)[^<>]+lilypond.org(?=<)/g,"");var x={name:"flex-engraver",components:{SourceEditor:h["a"],StoreInput:g["a"],BoolStoreInput:S["a"],SheetSimple:d["a"],Loading:v["a"]},data(){return{containerSize:{width:100,height:100,offsetWidth:1215,offsetHeight:495},dragHover:!1,sourceList:[],chosenSourceIndex:0,sourceDirty:!1,gaugeSvgDoc:null,staffSizeRange:{min:10,max:40},containerSvgs:null,containerEngraving:!1,staffSampleSvgMin:null,staffSampleSvgMax:null,fitStaffSize:24,fixStaffSize:!1}},computed:{currentSource(){return this.sourceList[this.chosenSourceIndex]},currentSourceContent(){return this.currentSource&&this.currentSource.content},containerSizeHash(){return`${this.containerSize.width},${this.containerSize.height}`}},async created(){window.$main=this,this.loadSource(),this.lilyParser=await Object(o["a"])(a.e("chunk-2d0db258").then(a.t.bind(null,"6f2d",7))),console.log("Lilypond parser loaded."),this.updateStaffSamples()},async mounted(){await this.$nextTick(),this.updateContainerSize()},beforeDestroy(){this.checkAndSaveSource()},methods:{updateContainerSize({widthOffset:e=!0}={}){this.containerSize.width=this.$refs.sheetContainer.clientWidth,this.containerSize.height=this.$refs.sheetContainer.clientHeight,e&&(this.containerSize.offsetWidth=this.$refs.sheetContainer.offsetWidth,this.containerSize.offsetHeight=this.$refs.sheetContainer.offsetHeight)},async onDropFile(e){this.dragHover=!1;const t=e.dataTransfer.files[0];if(t)switch(t.type){case"text/x-lilypond":case"text/lilypond-source":const e=await t.readAs("Text"),a=t.name.replace(/\.ly$/,"");this.sourceList.push({name:a,content:e}),this.sourceDirty=!0;break}},removeCurrentSource(){this.sourceList.splice(this.chosenSourceIndex,1),this.chosenSourceIndex=Math.min(this.chosenSourceIndex,this.sourceList.length-1)},loadSource(){localStorage.lotusFlexEngraverSources&&(this.sourceList=JSON.parse(localStorage.lotusFlexEngraverSources),console.log("Source list loaded.")),this.sourceDirty=!1},saveSource(){localStorage.lotusFlexEngraverSources=JSON.stringify(this.sourceList),console.log("Source list saved."),this.sourceDirty=!1},checkAndSaveSource(){this.sourceDirty&&this.saveSource()},async gauge(){const e=20,t=1e4,a=2,i=new c["a"](await this.lilyParser.parse(this.currentSourceContent)),n=i.globalAttributes();n.staffSize.value=e,n.paperWidth.value.number=t,n.paperHeight.value.number=1e3,n.raggedLast.value=!0,n.topMargin.value=0,n.leftMargin.value=0;const r=i.toString();try{const s=await this.engrave(r,{tokenize:!0});this.gaugeSvgDoc=s.svgs[0],console.assert(1===s.svgs.length,"invalid page count:",s);const o=Object(l["b"])(s.doc,{StaffToken:f["StaffToken"],SheetDocument:f["SheetDocument"]}),u=o.pages[0].systems[0],h=t/o.pages[0].viewBox.width/e,g=u.width*h,S=(u.bottom-u.top)*h;n.paperWidth.value.number=a;const d=await this.engrave(i.toString(),{tokenize:!0});console.assert(1===d.svgs.length,"invalid page count:",d);const v=Object(l["b"])(d.doc,{StaffToken:f["StaffToken"],SheetDocument:f["SheetDocument"]}),m=v.pages[0].systems,p=Array(m.length-1).fill(null).map((e,t)=>m[t+1].y-m[t].y),x=Math.max(u.bottom-u.top,...p)*h-S,w=new c["a"](await this.lilyParser.parse(this.currentSourceContent));w.root.appendAssignment("naturalWidth",g),w.root.appendAssignment("naturalHeight",S),w.root.appendAssignment("systemSpacing",x),this.currentSource.content=w.toString(),this.checkAndSaveSource()}catch(s){console.warn("Engraving failed:",s)}},async engrave(e,{tokenize:t}={}){const a=new FormData;a.append("source",e),t&&a.append("tokenize",t);const i=await fetch("/engrave",{method:"POST",body:a});if(!i.ok)throw new Error(await i.text());return i.json()},async fitContainer(){if(!this.lilyParser||!this.currentSourceContent)return null;const e=new c["a"](await this.lilyParser.parse(this.currentSourceContent)),t=e.root.getField("naturalWidth"),a=e.root.getField("naturalHeight"),i=e.root.getField("systemSpacing");if(!t||!a||!i)return console.log("natural size is not set.",t,a),null;const n=t.value,r=a.value,s=i.value+.04,o=e.globalAttributes(),l=this.containerSize.width/u["a"],f=(this.containerSize.height-9)/u["a"],h=e=>o[e].value?o[e].value.number:null,g=h("leftMargin")||u["d"],S=h("rightMargin")||u["d"],d=h("topMargin")||u["f"],v=h("bottomMargin")||u["c"],m=f-d-v,p=l-g-S;let x=1,w=null;if(this.fixStaffSize){w=this.fitStaffSize;const e=(n-u["g"])*w/(p-u["g"]*w);x=Math.ceil(e-.2)}else{for(;x<1e3;++x){const e=m/(r*x+s*(x-1));if(e<this.staffSizeRange.min){Number.isFinite(w)||(w=e),--x,console.log("too samll vertical prefered staff size:",e,x);break}w=Math.min(e,this.staffSizeRange.max);const t=(n-u["g"])*w/(p-u["g"]*w);if(t<0)return void console.warn("Horizontal space too little:",t,p-u["g"]*w);if(t<x+.2){x=Math.max(Math.round(t),1),console.log("proper xsc:",t,x);break}}if(console.log("systemCount:",x,w),w<=this.staffSizeRange.min)return void console.warn("Vertical space too little:",w)}const z=(n-u["g"])*w/(p-u["g"]*w);console.log("horizontalNaturalCount:",z,x);const b=w*(r*x+s*(x-1)),y=Math.max(.9*(f-b)/2,0);if(o.topMargin.value={proto:"NumberUnit",number:y,unit:"\\cm"},1===x){const e=w*n,t=.9*(l-e)/2;t>1&&(o.leftMargin.value={proto:"NumberUnit",number:t,unit:"\\cm"},o.rightMargin.value={proto:"NumberUnit",number:t,unit:"\\cm"})}return o.staffSize.value=w,o.paperWidth.value={proto:"NumberUnit",number:l,unit:"\\cm"},o.paperHeight.value={proto:"NumberUnit",number:f,unit:"\\cm"},o.raggedLast.value=x<=1&&z<.8,this.fixStaffSize||(this.fitStaffSize=w),e.toString()},async renderSheet(){const e=await this.fitContainer();if(!e)return;this.containerEngraving=!0;const t=await this.engrave(e,{tokenize:!1});this.containerSvgs=t.svgs,this.containerSvgs=this.containerSvgs.map(p),this.containerEngraving=!1},async exportScore(){const e=await this.fitContainer();if(!e)return void console.warn("no source.");const t=await this.engrave(e,{tokenize:!0}),a={doc:Object(l["b"])(t.doc,{StaffToken:f["StaffToken"],SheetDocument:f["SheetDocument"]}),midi:t.midi,hashTable:t.hashTable},i=new Blob([JSON.stringify(a)]);Object(r["a"])(URL.createObjectURL(i),"score.json")},async copySource(){const e=await this.fitContainer();navigator.clipboard.writeText(e),console.log("Source copyed.")},async exportSourceList(){const e=JSON.stringify(this.sourceList),t=new Blob([e],{type:"text/plain"});Object(r["a"])(URL.createObjectURL(t),"FlexEngraverSources.json")},async delayRenderSheet(){await Object(s["b"])("renderSheet",500)&&this.renderSheet()},async engraveSample(e){const t=m(e),a=await this.engrave(t);return a.svgs[0]},async updateStaffSampleMin(){this.staffSampleSvgMin=p(await this.engraveSample(this.staffSizeRange.min))},async updateStaffSampleMax(){this.staffSampleSvgMax=p(await this.engraveSample(this.staffSizeRange.max))},updateStaffSamples(){this.updateStaffSampleMin(),this.updateStaffSampleMax()}},watch:{currentSourceContent(e,t){e&&void 0!==t&&(this.sourceDirty=!0)},async chosenSourceIndex(){this.gaugeSvgDoc=null,this.checkAndSaveSource(),await this.$nextTick(),this.sourceDirty=!1,this.renderSheet()},containerSizeHash:"delayRenderSheet",fixStaffSize(e){e||this.delayRenderSheet()}}},w=x,z=(a("1e1a"),a("2877")),b=Object(z["a"])(w,i,n,!1,null,null,null);t["default"]=b.exports}}]);
+//# sourceMappingURL=chunk-117382e0.d47336d3.js.map

dist/js/chunk-2d0c53c7.d24941b8.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-2d0c53c7"],{"3ddd":function(C,J){C.exports="data:;base64,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"}}]);
+//# sourceMappingURL=chunk-2d0c53c7.d24941b8.js.map

dist/js/chunk-2d0db258.a4804a7a.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-2d0db258"],{"6f2d":function(C,J){C.exports="data:;base64,
%{
	const preferNumber = x => Number.isFinite(Number(x)) ? Number(x) : x;

	const location = (begin, end) => ({proto: "_PLAIN", lines: [begin.first_line, end.last_line], columns: [begin.first_column, end.last_column]});

	const commandSubProtos = {
		markup: "MarkupCommand",
		repeat: "Repeat",
		relative: "Relative",
		parallelMusic: "ParallelMusic",
		time: "TimeSignature",
		partial: "Partial",
		times: "Times",
		tuplet: "Tuplet",
		clef: "Clef",
		key: "KeySignature",
		ottava: "OctaveShift",
		include: "Include",
		version: "Version",
		lyricmode: "LyricMode",
		chordmode: "ChordMode",
		grace: "Grace",
		acciaccatura: "Grace",
		appoggiatura: "Grace",
		slashedGrace: "Grace",
		afterGrace: "AfterGrace",
		language: "Language",
		transposition: "Transposition",
		stemUp: "StemDirection",
		stemDown: "StemDirection",
		stemNeutral: "StemDirection",
		change: "Change",
	};


	const root = (sections = []) => ({proto: "Root", sections});

	const appendSection = (list, item) => {
		list.sections.push(item);

		return list;
	};

	const string = exp => ({proto: "LiteralString", exp});

	const command = (cmd, ...args) => ({proto: commandSubProtos[cmd.substr(1)] || "Command", cmd: cmd.substr(1), args});

	const variable = name => ({proto: "Variable", name: name.substr(1)});

	const chord = (pitches, duration, {locations, post_events, ...options} = {}) => ({proto: "Chord", pitches, duration, post_events, _location: location(...locations), options: {...options, proto: "_PLAIN"}});

	const rest = ({name, duration, post_events = null, locations}) => ({proto: "Rest", name, duration, post_events, _location: location(...locations)});

	const chordElem = (pitch, {locations, ...options}) => ({proto: "ChordElement", pitch, _location: location(...locations), options: {...options, proto: "_PLAIN"}});

	const briefChord = (body, {locations, post_events = null} = {}) => ({proto: "BriefChord", body: {...body, proto: "_PLAIN"}, post_events, _location: location(...locations)});

	const block = (block, head, body = []) => ({proto: "Block", block, head, body});

	const inlineBlock = body => ({proto: "InlineBlock", body});

	const scheme = exp => ({proto: "Scheme", exp});

	const schemeFunction = (func, args) => ({proto: "SchemeFunction", func, args});

	const schemePair = (left, right) => ({proto: "SchemePair", left, right});

	const schemePointer = value => ({proto: "SchemePointer", value});

	const schemeEmbed = value => ({proto: "SchemeEmbed", value});

	const assignment = (key, value) => ({proto: "Assignment", key, value});

	const numberUnit = (number, unit) => ({proto: "NumberUnit", number: preferNumber(number), unit});

	const musicBlock = body => ({proto: "MusicBlock", body});

	const simultaneousList = list => ({proto: "SimultaneousList", list});

	const contextedMusic = (head, body, lyrics) => ({proto: "ContextedMusic", head, body, lyrics});

	const tempo = (beatsPerMinute, unit, text) => ({proto: "Tempo", beatsPerMinute: preferNumber(beatsPerMinute), unit: preferNumber(unit), text});

	const postEvent = (direction, arg) => ({proto: "PostEvent", direction, arg});

	const fingering = value => ({proto: "Fingering", value: preferNumber(value)});

	const markup = (head, body) => ({proto: "Markup", head, body});

	const lyric = (content, {locations, ...options}) => ({proto: "Lyric", content, _location: location(...locations), ...options});

	const duration = ({number, dots, multipliers}) => ({proto: "Duration", number, dots, multipliers});

	const comment = ({loc, ...data}) => ({proto: "Comment", _location: location(loc, loc), ...data});


	let lineHeadTable = {};
	let lineTailTable = {};

	const lineHead = (loc, term) => {
		if (!term || typeof term !== "object")
			return;

		if (!lineHeadTable[loc.first_line] || lineHeadTable[loc.first_line].column > loc.first_column)
			lineHeadTable[loc.first_line] = {column: loc.first_column, term};
	};

	const lineTail = (loc, term) => {
		if (!term || typeof term !== "object")
			return;

		if (!lineTailTable[loc.last_line] || lineTailTable[loc.last_line].column < loc.last_column)
			lineTailTable[loc.last_line] = {column: loc.last_column, term};
	};

	const lineRegister = (loc, term) => {
		lineHead(loc, term);
		lineTail(loc, term);
	};


	const attachComments = yy => {
		if (yy.$lotusComments && yy.$lotusComments.length > 0) {
			//console.log("attachComments:", yy.$lotusComments, lineTable);
			const headLineNumbers = Object.keys(lineHeadTable).map(Number);

			yy.$lotusComments.forEach(data => {
				const comm = comment(data);

				const tailLine = lineTailTable[data.loc.first_line];
				if (tailLine) {
					tailLine.term._tailComment = comm;
					return;
				}

				const line = headLineNumbers.find(line => line >= data.loc.last_line);
				if (Number.isFinite(line) && lineHeadTable[line]) {
					lineHeadTable[line].term._headComment = comm;
					return;
				}

				// TODO: attach on root's tail
			});
		}

		// reset parser states
		lineHeadTable = {};
		lineTailTable = {};
	};
%}


%lex

%option flex unicode

A					[a-zA-Z\200-\377]
AA					{A}|_
N					[0-9]
ANY_CHAR			(.|\n)
SYMBOL				{A}([-_]{A}|{A})*
COMMAND				\\{SYMBOL}
/* SPECIAL category is for every letter that needs to get passed to
 * the parser rather than being redefinable by the user */
SPECIAL				[-+*/=<>{}!?_^'',.:]
SHORTHAND			(.|\\.)
UNSIGNED			{N}+
E_UNSIGNED			\\{N}+
FRACTION			{N}+\/{N}+
//INT					[-]?{UNSIGNED}
//REAL				({INT}\.{N}*)|([-]?\.{N}+)
STRICTREAL			{UNSIGNED}\.{UNSIGNED}
WHITE				[ \n\t\f\r]
HORIZONTALWHITE		[ \t]
BLACK				[^ \n\t\f\r]
RESTNAME			[rRs](?=[\W\d_])
ESCAPED				[nt\\''""]
//EXTENDER			\_\_
//HYPHEN				\-\-
PRE_EXTENDER		\_(?=\_)
PRE_HYPHEN			\-(?=\-)
BOM_UTF8			\357\273\277

PHONET				[abcdefgqh]
PITCH				{PHONET}(([i][s])*|([e][s])*|[s][e][s]|[s]*|[f]*)(?=[\W\d_])
//PLACEHOLDER_PITCH	[s](?=[\W\d_^-])
//DURATION			"1"|"2"|"4"|"8"|"16"|"32"|"64"|"128"|"256"

//UNICODE_HAN			[\p{Script=Han}]

%%

// extra lex
// TODO: parse the dollar expression details
[$][(][^()]*[)]						return 'DOLLAR_SCHEME_EXPRESSION'

\s+									{}	// spaces
\%\{(.|\n)*?\%\}					yy.$lotusComments = yy.$lotusComments || []; yy.$lotusComments.push({text: yytext, loc: yylloc, scoped: true});	// scoped comments
\%.*								yy.$lotusComments = yy.$lotusComments || []; yy.$lotusComments.push({text: yytext, loc: yylloc});	// scoped comments
\"(\\\"|[^"])*\"					return 'STRING';

//{EXTENDER}							return 'EXTENDER';
//{HYPHEN}							return 'HYPHEN';
{PRE_EXTENDER}						return 'PRE_EXTENDER';
{PRE_HYPHEN}						return 'PRE_HYPHEN';

//"/+"								return CHORD_BASS;
//"^"								return CHORD_CARET;
//":"								return CHORD_COLON;
//"-"								return CHORD_MINUS;
//"/"								return CHORD_SLASH;

//"<"								return 'ANGLE_OPEN';
//">"								return 'ANGLE_CLOSE';
"<<"								return 'DOUBLE_ANGLE_OPEN';
">>"								return 'DOUBLE_ANGLE_CLOSE';

"\\\\"								return 'E_BACKSLASH';

{E_UNSIGNED}						return 'E_UNSIGNED';

"\\new"								return 'NEWCONTEXT';

"\\cm"								return 'CENTIMETER';
"\\mm"								return 'MILLIMETER';

"\\overrideProperty"				return 'OVERRIDEPROPERTY';

// binary commands
"\\relative"						return 'CMD_RELATIVE';
"\\tweak"							return 'CMD_TWEAK';
"\\key"								return 'CMD_KEY';
//"\\times"							return 'CMD_TIMES';
[\\][t][i][m][e][s]					return 'CMD_TIMES';
"\\afterGrace"						return 'CMD_AFTERGRACE';
"\\parallelMusic"					return 'CMD_PARALLELMUSIC';
"\\shape"							return 'CMD_SHAPE';
"\\tag"								return 'CMD_TAG';
"\\scaleDurations"					return 'CMD_SCALEDURATIONS';

// unitary commands
"\\clef"							return 'CMD_CLEF';
"\\time"							return 'CMD_TIME';
"\\stemUp"							return 'CMD_STEMUP';
"\\stemDown"						return 'CMD_STEMDOWN';
"\\stemNeutral"						return 'CMD_STEMNEUTRAL';
"\\bar"								return 'CMD_BAR';
"\\omit"							return 'CMD_OMIT';
"\\ottava"							return 'CMD_OTTAVA';
"\\barNumberCheck"					return 'CMD_BARNUMBERCHECK';
"\\partial"							return 'CMD_PARTIAL';
"\\mark"							return 'CMD_MARK';
"\\include"							return 'CMD_INCLUDE';
"\\tupletSpan"						return 'CMD_TUPLETSPAN';
"\\tuplet"							return 'CMD_TUPLET';
"\\tupletNeutral"					return 'CMD_TUPLETNEUTRAL';
"\\skip"							return 'CMD_SKIP';
"\\skip"(?=\d)						return 'CMD_SKIP';
"\\parenthesize"					return 'CMD_PARENTHESIZE';
"\\unfoldRepeats"					return 'CMD_UNFOLDREPEATS';
"\\grace"							return 'CMD_GRACE';
"\\acciaccatura"					return 'CMD_ACCIACCATURA';
"\\appoggiatura"					return 'CMD_APPOGGIATURA';
"\\slashedGrace"					return 'CMD_SLASHEDGRACE';
"\\language"						return 'CMD_LANGUAGE';
"\\once"							return 'CMD_ONCE';
"\\accidentalStyle"					return 'CMD_ACCIDENTALSTYLE';
"\\numericTimeSignature"			return 'CMD_NUMERICTIMESIGNATURE';
"\\defaultTimeSignature"			return 'CMD_DEFAULTTIMESIGNATURE';
"\\bendAfter"						return 'CMD_BENDAFTER';
"\\compoundMeter"					return 'CMD_COMPOUNDMETER';
"\\transposition"					return 'CMD_TRANSPOSITION';
"\\absolute"						return 'CMD_ABSOLUTE';
"\\hide"							return 'CMD_HIDE';
"\\crossStaff"						return 'CMD_CROSSSTAFF';
"\\keepWithTag"						return 'CMD_KEEPWITHTAG';
"\\articulate"						return 'CMD_ARTICULATE';

// zero commands
"\\tempoLegend"						return 'CMD_TEMPOLEGEND';
"\\fermata"							return 'CMD_FERMATA';
"\\mergeDifferentlyDottedOn"		return 'CMD_MERGEDIFFERENTLYDOTTEDON';
"\\mergeDifferentlyHeadedOn"		return 'CMD_MERGEDIFFERENTLYHEADEDON';
"\\voiceOne"						return 'CMD_VOICE_NUMBER';
"\\voiceTwo"						return 'CMD_VOICE_NUMBER';
"\\voiceThree"						return 'CMD_VOICE_NUMBER';
"\\voiceFour"						return 'CMD_VOICE_NUMBER';
//"\\voiceFive"						return 'CMD_VOICE_NUMBER';
"\\Score"							return 'CMD_SCORE';
"\\Voice"							return 'CMD_VOICE';
"\\Staff"							return 'CMD_STAFF';
"\\PianoStaff"						return 'CMD_PIANOSTAFF';
"\\arpeggio"						return 'CMD_ARPEGGIO';
"\\arpeggioArrowDown"				return 'CMD_ARPEGGIOARROWDOWN';
"\\arpeggioArrowUp"					return 'CMD_ARPEGGIOARROWUP';
"\\arpeggioNormal"					return 'CMD_ARPEGGIONORMAL';
"\\arpeggioBracket"					return 'CMD_ARPEGGIOBRACKET';
"\\arpeggioParenthesis"				return 'CMD_ARPEGGIOPARENTHESIS';
"\\arpeggioParenthesisDashed"		return 'CMD_ARPEGGIOPARENTHESISDASHED';
"\\glissando"						return 'CMD_GLISSANDO';
"\\mordent"							return 'CMD_MORDENT';
"\\musicglyph"						return 'CMD_MUSICGLYPH';
"\\powerChords"						return 'CMD_POWERCHORDS';
"\\prall"							return 'CMD_PRALL';
"\\sustainOff"						return 'CMD_SUSTAINOFF';
"\\sustainOn"						return 'CMD_SUSTAINON';
"\\trill"							return 'CMD_TRILL';
"\\turn"							return 'CMD_TURN';
"\\pointAndClickOff"				return 'CMD_POINTANDCLICKOFF';
"\\upbow"							return 'CMD_UPBOW';
"\\downbow"							return 'CMD_DOWNBOW';
"\\breathe"							return 'CMD_BREATHE';
"\\startTextSpan"					return 'CMD_STARTTEXTSPAN';
"\\stopTextSpan"					return 'CMD_STOPTEXTSPAN';
"\\flageolet"						return 'CMD_FLAGEOLET';
"\\slurDashed"						return 'CMD_SLURDASHED';
"\\slurSolid"						return 'CMD_SLURSOLID';
"\\break"							return 'CMD_BREAK';
"\\pageBreak"						return 'CMD_PAGEBREAK';
"\\startTrillSpan"					return 'CMD_STARTTRILLSPAN';
"\\stopTrillSpan"					return 'CMD_STOPTRILLSPAN';
"\\cadenzaOn"						return 'CMD_CADENZAON';
"\\cadenzaOff"						return 'CMD_CADENZAOFF';
"\\cresc"							return 'CMD_CRESC';
"\\crescTextCresc"					return 'CMD_CRESCTEXTCRESC';
"\\crescHairpin"					return 'CMD_CRESCHAIRPIN';
"\\dim"(?=[\W])						return 'CMD_DIM';
"\\dimTextDim"						return 'CMD_DIMTEXTDIM';
"\\dynamicUp"						return 'CMD_DYNAMICUP';
"\\hideNotes"						return 'CMD_HIDENOTES';
"\\unHideNotes"						return 'CMD_UNHIDENOTES';
"\\newSpacingSection"				return 'CMD_NEWSPACINGSECTION';
"\\noBeam"							return 'CMD_NOBEAM';
"\\oneVoice"						return 'CMD_ONEVOICE';
"\\phrasingSlurDown"				return 'CMD_PHRASINGSLURDOWN';
"\\phrasingSlurNeutral"				return 'CMD_PHRASINGSLURNEUTRAL';
"\\phrasingSlurUp"					return 'CMD_PHRASINGSLURUP';
"\\slurDown"						return 'CMD_SLURDOWN';
"\\slurNeutral"						return 'CMD_SLURNEUTRAL';
"\\slurUp"							return 'CMD_SLURUP';
"\\tieDown"							return 'CMD_TIEDOWN';
"\\tieNeutral"						return 'CMD_TIENEUTRAL';
"\\tieUp"							return 'CMD_TIEUP';
"\\tupletUp"						return 'CMD_TUPLETUP';
"\\tupletDown"						return 'CMD_TUPLETDOWN';
"\\shiftOn"							return 'CMD_SHIFTON';
"\\repeatTie"						return 'CMD_REPEATTIE';
"\\marcato"							return 'CMD_MARCATO';
"\\stopped"							return 'CMD_STOPPED';
"\\tenuto"							return 'CMD_TENUTO';
"\\staccatissimo"					return 'CMD_STACCATISSIMO';
"\\accent"							return 'CMD_ACCENT';
"\\staccato"						return 'CMD_STACCATO';
"\\portato"							return 'CMD_PORTATO';

"\\mp"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\mf"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\"[p]+(?=[\W])					return 'CMD_DYNAMIC_MARKINGS';
"\\"[f]+(?=[\W])					return 'CMD_DYNAMIC_MARKINGS';
"\\sf"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\sff"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\sfp"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\sfpp"(?=[\W])					return 'CMD_DYNAMIC_MARKINGS';
"\\fp"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\mfp"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\rf"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\rfz"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\sfz"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\sffz"(?=[\W])					return 'CMD_DYNAMIC_MARKINGS';
"\\fz"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\fzp"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\ffz"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';
"\\ppz"(?=[\W])						return 'CMD_DYNAMIC_MARKINGS';

"\\breve"							return 'CMD_BREVE';
"\\longa"							return 'CMD_LONGA';

// markup commands		
"\\version"							return 'CMD_VERSION';
"\\column"							return 'CMD_COLUMN';
"\\line"							return 'CMD_LINE';
"\\bold"							return 'CMD_BOLD';
"\\italic"							return 'CMD_ITALIC';
"\\box"								return 'CMD_BOX';
"\\whiteout"						return 'CMD_WHITEOUT';
"\\dynamic"							return 'CMD_DYNAMIC';
"\\abs-fontsize"					return 'CMD_ABS_FONTSIZE';
"\\with-color"						return 'CMD_WITH_COLOR';
"\\char"							return 'CMD_CHAR';
"\\center-column"					return 'CMD_CENTER_COLUMN';
"\\right-column"					return 'CMD_RIGHT_COLUMN';
"\\with-url"						return 'CMD_WITH_URL';
"\\sans"							return 'CMD_SANS';
"\\concat"							return 'CMD_CONCAT';
"\\maintainer"						return 'CMD_MAINTAINER';
"\\footnote"						return 'CMD_FOOTNOTE';
"\\natural"							return 'CMD_NATURAL';
"\\flat"							return 'CMD_FLAT';
"\\sharp"							return 'CMD_SHARP';
"\\hspace"							return 'CMD_HSPACE';
"\\footer"							return 'CMD_FOOTER';
"\\center-align"					return 'CMD_CENTER_ALIGN';
"\\right-align"						return 'CMD_RIGHT_ALIGN';
"\\general-align"					return 'CMD_GENERAL_ALIGN';
"\\lower"							return 'CMD_LOWER';
"\\finger"							return 'CMD_FINGER';
"\\fontsize"						return 'CMD_FONTSIZE';
"\\raise"							return 'CMD_RAISE';
"\\note"							return 'CMD_NOTE';
"\\circle"							return 'CMD_CIRCLE';
"\\pad-markup"						return 'CMD_PAD_MARKUP';
"\\smaller"							return 'CMD_SMALLER';
"\\normal-text"						return 'CMD_NORMAL_TEXT';

"\\huge"							return 'CMD_HUGE';
"\\large"							return 'CMD_LARGE';
"\\normalsize"						return 'CMD_NORMALSIZE';
"\\small"							return 'CMD_SMALL';
"\\tiny"							return 'CMD_TINY';
"\\teeny"							return 'CMD_TEENY';
"\\medium"							return 'CMD_MEDIUM';

// syntax commands		
"\\header"							return 'HEADER';
"\\markup"							return 'MARKUP';
"\\markuplist"						return 'MARKUPLIST';
"\\repeat"							return 'REPEAT';
"\\context"							return 'CONTEXT';
"\\accepts"							return 'ACCEPTS';
"\\addlyrics"						return 'ADDLYRICS';
"\\alias"							return 'ALIAS';
"\\alternative"						return 'ALTERNATIVE';
"\\book"							return 'BOOK';
"\\bookpart"						return 'BOOKPART';
"\\change"							return 'CHANGE';
"\\chordmode"						return 'CHORDMODE';
"\\chords"							return 'CHORDS';
"\\consists"						return 'CONSISTS';
"\\default"							return 'DEFAULT';
"\\defaultchild"					return 'DEFAULTCHILD';
"\\denies"							return 'DENIES';
"\\description"						return 'DESCRIPTION';
"\\drummode"						return 'DRUMMODE';
"\\drums"							return 'DRUMS';
"\\etc"								return 'ETC';
"\\figuremode"						return 'FIGUREMODE';
"\\figures"							return 'FIGURES';
"\\version-error"					return 'INVALID';
"\\layout"							return 'LAYOUT';
"\\lyricmode"						return 'LYRICMODE';
"\\lyrics"							return 'LYRICS';
"\\lyricsto"						return 'LYRICSTO';
"\\midi"							return 'MIDI';
"\\name"							return 'NAME';
"\\notemode"						return 'NOTEMODE';
"\\override"						return 'OVERRIDE';
"\\paper"							return 'PAPER';
"\\remove"							return 'REMOVE';
"\\rest"							return 'REST';
"\\revert"							return 'REVERT';
"\\score"							return 'SCORE';
"\\score-lines"						return 'SCORELINES';
"\\sequential"						return 'SEQUENTIAL';
"\\set"								return 'SET';
"\\simultaneous"					return 'SIMULTANEOUS';
"\\tempo"							return 'TEMPO';
"\\type"							return 'TYPE';
"\\unset"							return 'UNSET';
"\\with"							return 'WITH';

// simple commands
"\\<"								return 'CMD_CRESCENDO_BEGIN';
"\\>"								return 'CMD_DECRESCENDO_BEGIN';
"\\!"								return 'CMD_DYNAMICS_END';

{COMMAND}							return 'COMMAND';

{PITCH}								return 'PITCH';
//{PLACEHOLDER_PITCH}					return 'PLACEHOLDER_PITCH';
//{UNSIGNED}						return 'POST_UNSIGNED';
{RESTNAME}							return 'RESTNAME';

{FRACTION}							return 'FRACTION';
//{REAL}							return 'REAL';
{UNSIGNED}							return 'UNSIGNED';

//{INT}								return 'INT';

// CHORD_MODIFIER
[m][a][j](?=[\W\d])					return 'CHORD_MODIFIER_WORD';
m(?=[\W\d])							return 'CHORD_MODIFIER_WORD';
[a][u][g](?=[\W\d])					return 'CHORD_MODIFIER_WORD';
[d][i][m](?=[\W\d])					return 'CHORD_MODIFIER_WORD';
[s][u][s](?=[\W\d])					return 'CHORD_MODIFIER_WORD';

"inf.0"								return yytext;

{SYMBOL}							return 'SYMBOL';

"#f"								return 'SCM_FALSE';
"#t"								return 'SCM_TRUE';

"#x"[\da-fA-F]+						return 'SCM_HEX';

"#:"{SYMBOL}						return 'SCM_COLON';

"\\("								return yytext;
"\\)"								return yytext;

\.(?=\d)							return 'DOT_NUMBER_R';
//(?<=\d)\.							return 'DOT_NUMBER_L';

{SPECIAL}							return yytext;
\|									return 'DIVIDE';

[()]								return yytext;

"["									return yytext;
"]"									return yytext;

"#"									return yytext;
"~"									return yytext;
"`"									return yytext;

.									return 'UNKNOWN_CHAR';

<<EOF>>								return 'EOF';


/lex

%start start_symbol

%%

start_symbol
	: lilypond EOF
		{
			attachComments(yy);
			return $1;
		}
	//| embedded_lilypond
	;

lilypond
	: %empty
		{$$ = root();}
	| version
		{$$ = root([$1]); lineRegister(@1, $1);}
	| lilypond toplevel_expression
		{$$ = appendSection($1, $2); lineRegister(@2, $2);}
	| lilypond assignment
		{$$ = appendSection($1, $2); lineRegister(@2, $2);}
	;

version
	: CMD_VERSION literal_string
		{$$ = command($1, $2);}
	;

toplevel_expression
	: header_block
		{$$ = $1;}
	| composite_music
		{$$ = $1;}
	| full_markup
		{$$ = $1;}
	| output_def
		{$$ = $1;}
	| score_block
		{$$ = $1;}
	| book_block
		{$$ = $1;}
	| scm_identifier
		{$$ = $1;}
	//| full_markup_list
	//	{$$ = $1;}
	//| bookpart_block
	//| BOOK_IDENTIFIER
	//| SCM_TOKEN
	//| embedded_scm_active
	;

score_block
	: SCORE '{' score_body '}'
		{$$ = block("score", $1, $3);}
	;

book_block
	: BOOK '{' book_body '}'
		{$$ = block("book", $1, $3);}
	;

book_body
	: %empty
		{$$ = [];}
	//| BOOK_IDENTIFIER
	| book_body paper_block
		{$$.push($2);}
	//| book_body bookpart_block
	//	{$$.push($2);}
	| book_body score_block
		{$$.push($2);}
	| book_body composite_music
		{$$.push($2);}
	| book_body full_markup
		{$$.push($2);}
	| book_body full_markup_list
		{$$.push($2);}
	//| book_body SCM_TOKEN
	| book_body embedded_scm_active
		{$$.push($2);}
	| book_body lilypond_header
		{$$.push($2);}
	//| book_body error
	;

paper_block
	: output_def
		{$$ = $1;}
	;

header_block
	: lilypond_header
		{$$ = $1;}
	;

lilypond_header
	: HEADER '{' lilypond_header_body '}'
		{$$ = block("header", $1, $3);}
	;

lilypond_header_body
	: %empty
		{$$ = [];}
	| lilypond_header_body assignment
		{$$.push($2); lineRegister(@2, $2);}
	//| lilypond_header_body SCM_TOKEN
	//| lilypond_header_body embedded_scm_active
	;

assignment
	: assignment_id '=' identifier_init
		{$$ = assignment($1, $3);}
	| assignment_id '.' property_path '=' identifier_init
		{$$ = assignment($1 + "." + $3, $5);}
	//| markup_mode_word '=' identifier_init
	;

assignment_id
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	// extra formula
	| PITCH
		{$$ = $1;}
	// extra formula
	| CHORD_MODIFIER_WORD
		{$$ = $1;}
	;

property_path
	: symbol_list_rev
		{$$ = $1;}
	;

symbol_list_rev
	: symbol_list_part
		{$$ = $1;}
	| symbol_list_rev '.' symbol_list_part
		{$$ = $1 + "." + $3;}
	| symbol_list_rev ',' symbol_list_part
		{$$ = $1 + "," + $3;}
	;

symbol_list_part
	: symbol_list_part_bare
		{$$ = $1;}
	| embedded_scm_bare
		{$$ = $1;}
	;

symbol_list_part_bare
	: SYMBOL
		{$$ = $1;}
	| symbol_list_element
		{$$ = $1;}
	;

symbol_list_element
	: literal_string
		{$$ = $1;}
	| UNSIGNED
		{$$ = $1;}
	;

identifier_init
	: identifier_init_nonumber
		{$$ = $1;}
	| number_expression
		{$$ = $1;}
	//| symbol_list_part_bare '.' property_path
	//	{$$ = $1 + "." + $3;}
	//| symbol_list_part_bare ',' property_path
	//	{$$ = $1 + "," + $3;}
	| post_event_nofinger post_events
		{$$ = [$1, $2];}
	;

number_expression
	: number_expression '+' number_term
	| number_expression '-' number_term
	| number_term
	;

number_term
	: number_factor
	| number_factor '*' number_factor
	| number_factor '/' number_factor
	;

number_factor
	: '-'  number_factor
	| bare_number
	;

identifier_init_nonumber
	: header_block
		{$$ = $1;}
	| music_assign
		{$$ = $1;}
	//| full_markup_list
	//	{$$ = $1;}
	| string
		{$$ = $1;}
	| pitch_or_music
		{$$ = $1;}
	| FRACTION
		{$$ = $1;}
	| embedded_scm
		{$$ = $1;}
	| score_block
		{$$ = $1;}
	| output_def
		{$$ = $1;}
	| context_modification
		{$$ = $1;}
	| book_block
		{$$ = $1;}
	//| bookpart_block
	//| context_def_spec_block
	//| partial_markup
	//| partial_function ETC
	;

string
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| full_markup
		{$$ = $1;}
	;

text
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| full_markup
		{$$ = $1;}
	| embedded_scm_bare
		{$$ = $1;}
	;

full_markup_list
	: MARKUPLIST
		{$$ = $1;}
	| markup_list
		{$$ = $1;}
	;

markup_list
	: markup_composed_list
		{$$ = $1;}
	| markup_uncomposed_list
		{$$ = [$1];}
	;

markup_composed_list
	: markup_head_1_list markup_uncomposed_list
		//{$$ = block("markup", $1, $2);}
		{$$ = [...$1, $2];}
	;

markup_head_1_list
	: markup_head_1_item
		{$$ = [$1];}
	| markup_head_1_list markup_head_1_item
		{$$ = $1.concat([$2]);}
	;

markup_head_1_item
	//: markup_function EXPECT_MARKUP markup_command_list_arguments
	//: markup_function markup_command_list_arguments
	//	{$$ = {func: $1, args: $2};}
	: markup_function
		//{$$ = {func: $1};}
		{$$ = $1;}
	;

// equivalent for MARKUP_FUNCTION in lilypond's parser.yy
markup_function
	//: CMD_COLUMN
	//	{$$ = $1;}
	: CMD_LINE
		{$$ = $1;}
	//| CMD_BOLD
	//	{$$ = $1;}
	//| CMD_ITALIC
	//	{$$ = $1;}
	//| markup_font_size
	//	{$$ = $1;}
	| CMD_BOX
		{$$ = $1;}
	| CMD_WHITEOUT
		{$$ = $1;}
	| CMD_DYNAMIC
		{$$ = $1;}
	//| CMD_CENTER_COLUMN
	//	{$$ = $1;}
	//| CMD_WITH_URL
	//	{$$ = $1;}
	//| CMD_SANS
	//	{$$ = $1;}
	//| CMD_CONCAT
	//	{$$ = $1;}
	| CMD_MAINTAINER
		{$$ = $1;}
	;

// extra syntax
markup_font_size
	: CMD_HUGE
		{$$ = $1;}
	| CMD_LARGE
		{$$ = $1;}
	| CMD_NORMALSIZE
		{$$ = $1;}
	| CMD_SMALL
		{$$ = $1;}
	| CMD_TINY
		{$$ = $1;}
	| CMD_TEENY
		{$$ = $1;}
	| CMD_MEDIUM
		{$$ = $1;}
	;

markup_uncomposed_list
	: markup_braced_list
		{$$ = $1;}
	//| markup_command_list
	//| markup_scm MARKUPLIST_IDENTIFIER
	//| SCORELINES '{' score_body '}'
	;

markup_braced_list
	: '{' markup_braced_list_body '}'
		{$$ = inlineBlock($2);}
	;

markup_braced_list_body
	: %empty
		{$$ = [];}
	| markup_braced_list_body markup
		{$$ = $1.concat([$2]);}
	| markup_braced_list_body markup_list
		{$$ = $1.concat($2);}
	;

markup
	: markup_head_1_list simple_markup
		//{$$ = $1.concat([$2]);}
		{$$ = markup($1, $2);}
	| simple_markup
		{$$ = $1;}
	;

simple_markup
	: markup_word
		{$$ = $1;}
	| simple_markup_noword
		{$$ = $1;}
	;

markup_word
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| unsigned_number
		{$$ = $1;}
	| CMD_MUSICGLYPH
		{$$ = command($1);}
	| CMD_NATURAL
		{$$ = $1;}
	| CMD_FLAT
		{$$ = $1;}
	| CMD_SHARP
		{$$ = $1;}
	| CMD_FOOTER
		{$$ = $1;}
	| scm_identifier
		{$$ = $1;}
	// extra formula
	| music_property_def
		{$$ = $1;}
	| context_change
		{$$ = $1;}
	| pitch_mode_music
		{$$ = $1;}
	// extra formula
	| PITCH
		{$$ = $1;}
	// extra formula
	| REAL
		{$$ = $1;}
	// extra formula
	| INT
		{$$ = $1;}
	// extra formula
	| general_text
		{$$ = $1;}
	;

// extra syntax
long_extender
	: PRE_EXTENDER "_"
		{$$ = $1 + $2}
	| PRE_EXTENDER long_extender
		{$$ = $1 + $2}
	;

// extra syntax
general_text
	: CHORD_MODIFIER_WORD
		{$$ = $1;}
	| "."
		{$$ = $1;}
	| "-"
		{$$ = $1;}
	| "_"
		{$$ = $1;}
	| PRE_HYPHEN
		{$$ = $1;}
	| long_extender
		{$$ = $1;}
	| "="
		{$$ = $1;}
	| "'"
		{$$ = $1;}
	| ","
		{$$ = $1;}
	| ":"
		{$$ = $1;}
	| "/"
		{$$ = $1;}
	| "("
		{$$ = $1;}
	| ")"
		{$$ = $1;}
	| "*"
		{$$ = $1;}
	| "~"
		{$$ = $1;}
	| "!"
		{$$ = $1;}
	| "?"
		{$$ = $1;}
	| UNKNOWN_CHAR
		{$$ = $1;}
	//| PLACEHOLDER_PITCH
	//	{$$ = $1;}
	| RESTNAME
		{$$ = $1;}
	;

simple_markup_noword
	: SCORE '{' score_body '}'
		//{$$ = {score: $3};}
		{$$ = block("score", $1, $3);}
	| markup_function markup_command_basic_arguments
		//{$$ = {func: $1, args: $2};}
		{$$ = command($1, ...$2);}
	//| markup_scm MARKUP_IDENTIFIER
	// extra formula
	| OVERRIDE scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_ABS_FONTSIZE scm_identifier markup
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_ABS_FONTSIZE scm_identifier markup_list
		{$$ = command($1, $2, ...$3);}
	// extra formula
	| CMD_WITH_COLOR scm_identifier markup
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_CHAR scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_HSPACE scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_SANS markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_SANS markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_CONCAT markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_COLUMN markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_CENTER_COLUMN markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_RIGHT_COLUMN markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_FOOTNOTE string string
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_WITH_URL scalar string
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_WITH_URL scalar markup_list
		{$$ = command($1, $2, ...$3);}
	// extra formula
	| CMD_BOLD markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_BOLD markup
		{$$ = command($1, $2);}
	// extra formula
	| markup_font_size markup
		{$$ = command($1, $2);}
	// extra formula
	| markup_font_size markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_ITALIC markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_ITALIC markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_CENTER_ALIGN markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_CENTER_ALIGN markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_RIGHT_ALIGN markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_RIGHT_ALIGN markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_GENERAL_ALIGN scm_identifier scm_identifier markup
		{$$ = command($1, $2, $3, $4);}
	// extra formula
	| CMD_LOWER scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_FINGER string
		{$$ = command($1, $2);}
	// extra formula
	| CMD_FONTSIZE scm_identifier markup
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_FONTSIZE scm_identifier markup_list
		{$$ = command($1, $2, $3);}
	// extra formula
	| CMD_RAISE scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_NOTE scm_identifier scm_identifier markup
		{$$ = command($1, $2, $3, $4);}
	// extra formula
	| CMD_CIRCLE markup_list
		{$$ = command($1, ...$2);}
	// extra formula
	| CMD_CIRCLE markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_PAD_MARKUP scm_identifier
		{$$ = command($1, $2);}
	// extra formula
	| CMD_SMALLER markup
		{$$ = command($1, $2);}
	// extra formula
	| CMD_NORMAL_TEXT markup
		{$$ = command($1, $2);}
	;

markup_command_basic_arguments
	: %emtpy
		{$$ = [];}
	| /*EXPECT_MARKUP_LIST*/ markup_command_list_arguments markup_list
		{$$ = $1.concat($2);}
	| /*EXPECT_SCM*/ markup_command_list_arguments markup_command_embedded_lilypond
		{$$ = $1.concat($2);}
	//| EXPECT_SCM markup_command_list_arguments embedded_scm
	//| EXPECT_SCM markup_command_list_arguments mode_changed_music
	//| EXPECT_SCM markup_command_list_arguments MUSIC_IDENTIFIER
	//| EXPECT_SCM markup_command_list_arguments literal_string
	//| EXPECT_NO_MORE_ARGS
	;

markup_command_list_arguments
	: markup_command_basic_arguments
		{$$ = [$1];}
	| /*EXPECT_MARKUP*/ markup_command_list_arguments markup
		{$$ = $1.concat($2);}
	;

markup_command_embedded_lilypond
	: '{' embedded_lilypond '}'
		{$$ = $2;}
	;

embedded_lilypond
	: %empty
		{$$ = $1;}
	| identifier_init_nonumber
		{$$ = $1;}
	| embedded_lilypond_number
		{$$ = $1;}
	| post_event
		{$$ = $1;}
	//| duration post_events %prec ':'
	| music_embedded music_embedded music_list
		{$$ = [$1, $2, $3];}
	//| error
	//| INVALID embedded_lilypond
	;

embedded_lilypond_number
	: '-' embedded_lilypond_number
		{$$ = -$1;}
	| bare_number_common
		{$$ = $1;}
	//| UNSIGNED NUMBER_IDENTIFIER
	;

bare_number_common
	: REAL
		{$$ = Number($1);}
	//| NUMBER_IDENTIFIER
	//| REAL NUMBER_IDENTIFIER
	| number_identifier
		{$$ = $1;}
	| FRACTION
		{$$ = $1;}
	;

// extra syntax
dot
	: "."
		{$$ = $1;}
	| DOT_NUMBER_R
		{$$ = $1;}
	;

INT
	: UNSIGNED
		{$$ = Number($1);}
	| "-" UNSIGNED
		{$$ = -Number($2);}
	;

// extra syntax
positive_real
	: UNSIGNED DOT_NUMBER_R UNSIGNED
		{$$ = Number($1 + $2 + $3);}
	//| UNSIGNED DOT_NUMBER_L
	//	{$$ = Number($1 + $2);}
	| DOT_NUMBER_R UNSIGNED
		{$$ = Number($1 + $2);}
	;

REAL
	: positive_real
		{$$ = $1;}
	| "-" positive_real
		{$$ = -$2;}
	;

// equivalent for NUMBER_IDENTIFIER in lilypond's parser.yy
number_identifier
	: REAL number_unit
		{$$ = numberUnit($1, $2);}
	//| INT number_unit
	//	{$$ = numberUnit($1, $2);}
	| UNSIGNED number_unit
		{$$ = numberUnit($1, $2);}
	;

// addon term to construct number_identifier
number_unit
	: CENTIMETER
		{$$ = $1;}
	| MILLIMETER
		{$$ = $1;}
	;

score_body
	: score_items
		{$$ = $1;}
	//| score_body error
	;

score_items
	: %empty
		{$$ = [];}
	| score_items score_item
		{$$ = $1.concat([$2]); lineHead(@2, $2);}
	| score_items lilypond_header
		{$$ = $1.concat([$2]); lineHead(@2, $2);}
	;

score_item
	: music
		{$$ = $1;}
	| output_def
		{$$ = $1;}
	//: embedded_scm
	;

//markup_command_list
//	: MARKUP_LIST_FUNCTION markup_command_list_arguments
//	;

markup_scm
	: embedded_scm
		{$$ = $1;}
	;

embedded_scm
	: embedded_scm_bare
		{$$ = $1;}
	//| scm_function_call
	//| lookup
	;

scm_function_call
	: SCM_FUNCTION function_arglist
	;

function_arglist
	: function_arglist_nonbackup
		{$$ = $1;}
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_skip_nonbackup DEFAULT
	;

function_arglist_nonbackup
	: function_arglist_common
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup post_event_nofinger
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' UNSIGNED
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' REAL
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup '-' NUMBER_IDENTIFIER
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup embedded_scm_arg
	//| EXPECT_OPTIONAL EXPECT_SCM function_arglist_nonbackup bare_number_common
	| function_arglist_nonbackup_reparse REPARSE pitch_or_music
	| function_arglist_nonbackup_reparse REPARSE duration
	| function_arglist_nonbackup_reparse REPARSE reparsed_rhythm
	| function_arglist_nonbackup_reparse REPARSE bare_number_common
	| function_arglist_nonbackup_reparse REPARSE SCM_ARG
	| function_arglist_nonbackup_reparse REPARSE lyric_element_music
	| function_arglist_nonbackup_reparse REPARSE symbol_list_arg
	;

function_arglist_common
	//: EXPECT_NO_MORE_ARGS
	: %empty
	//| EXPECT_SCM function_arglist_optional embedded_scm_arg
	//| EXPECT_SCM function_arglist_optional bare_number_common
	//| EXPECT_SCM function_arglist_optional post_event_nofinger
	//| EXPECT_SCM function_arglist_optional '-' NUMBER_IDENTIFIER
	| function_arglist_common_reparse REPARSE SCM_ARG
	| function_arglist_common_reparse REPARSE lyric_element_music
	| function_arglist_common_reparse REPARSE pitch_or_music
	| function_arglist_common_reparse REPARSE bare_number_common
	| function_arglist_common_reparse REPARSE duration
	| function_arglist_common_reparse REPARSE reparsed_rhythm
	| function_arglist_common_reparse REPARSE symbol_list_arg
	;

lookup
	: LOOKUP_IDENTIFIER
		{$$ = $1;}
	| LOOKUP_IDENTIFIER '.' symbol_list_rev
		{$$ = $1 + "." + $2;}
	;

symbol_list_part
	: symbol_list_part_bare
		{$$ = $1;}
	| embedded_scm_bare
		{$$ = $1;}
	;

embedded_scm_bare
	//: SCM_TOKEN
	//| SCM_IDENTIFIER
	: scm_identifier
		{$$ = $1;}
	;

// equivalent for SCM_IDENTIFIER in lilypond parser.yy
scm_identifier
	//: SCM_FALSE
	//	{$$ = scheme(false);}
	//| SCM_TRUE
	//	{$$ = scheme(true);}
	//| SCM_INT
	//	{$$ = scheme($1.substr(1));}
	//| "#" "'" SYMBOL
	//	{$$ = scheme("'" + $3);}
	: "#" scheme_expression
		{$$ = scheme($2);}
	| DOLLAR_SCHEME_EXPRESSION
		{$$ = $1;}
	;

composite_music
	: basic_music
		{$$ = $1;}
	| contexted_basic_music
		{$$ = $1;}
	//| basic_music new_lyrics
	;

contexted_basic_music
	: context_prefix contextable_music new_lyrics
		{$$ = contextedMusic($1, $2, $3);}
	| context_prefix contextable_music
		{$$ = contextedMusic($1, $2);}
	| context_prefix contexted_basic_music
		{$$ = contextedMusic($1, $2);}
	;

contextable_music
	: basic_music
		{$$ = $1;}
	| pitch_as_music
		{$$ = $1;}
	| event_chord
		{$$ = $1;}
	// extra formula
	| variable_command
		{$$ = $1;}
	;

new_lyrics
	: ADDLYRICS optional_context_mods lyric_mode_music
		{$$ = [{addLyrics: $3, mods: $2}];}
	| new_lyrics ADDLYRICS optional_context_mods lyric_mode_music
		{$$ = $1.concat([{addLyrics: $4, mods: $3}]);}
	;

lyric_mode_music
	: grouped_music_list
		{$$ = $1;}
	//| MUSIC_IDENTIFIER
	| music_identifier
		{$$ = $1;}
	;

context_prefix
	: CONTEXT symbol optional_id optional_context_mods
		//{$$ = {context: $2, assign: $3, mods: $4};}
		{$$ = command($1, $2, $3, ...$4);}
	| NEWCONTEXT symbol optional_id optional_context_mods
		//{$$ = {context: $2, new: true, assign: $3, mods: $4};}
		{$$ = command($1, $2, $3, ...$4);}
	;

optional_id
	: %empty
		{$$ = null;}
	| '=' simple_string
		{$$ = assignment(null, $2);}
	;

optional_context_mods
	: context_modification_mods_list
		{$$ = $1;}
	;

context_modification_mods_list
	: %empty
		{$$ = [];}
	| context_modification_mods_list context_modification
		{$$ = $1.concat($2);}
	;

basic_music
	: repeated_music
		{$$ = $1;}
	| music_bare
		{$$ = $1;}
	| LYRICSTO simple_string lyric_mode_music
		{$$ = command($1, $2, $3);}
	| LYRICSTO symbol '=' simple_string lyric_mode_music
		{$$ = command($1, assignment($2, $4), $5);}
	;

music_bare
	: grouped_music_list
		{$$ = $1;}
	| music_identifier
		{$$ = $1;}
	| mode_changed_music
		{$$ = $1;}
	;

mode_changed_music
	: mode_changing_head grouped_music_list
		{$$ = command($1, $2);}
	| mode_changing_head_with_context optional_context_mods grouped_music_list
		{$$ = command($1, ...$2, $3);}
	// extra formula
	| CHORDMODE chordmode_braced_music_list
		{$$ = command($1, $2);}
	// extra formula
	| LYRICMODE lyricmode_braced_music_list
		{$$ = command($1, $2);}
	;

// extra syntax
lyricmode_braced_music_list
	: '{' lyricmode_music_list '}'
		{$$ = musicBlock($2);}
	;

// extra syntax
lyricmode_music_list
	: %empty
		{$$ = [];}
	| lyricmode_music_list lyricmode_music
		{$$ = $1.concat([$2]);}
	;

// extra syntax
lyricmode_music
	: lyric_element_music
		{$$ = $1;}
	//| music_assign
	//	{$$ = $1;}
	| music_property_def
		{$$ = $1;}
	| lyricmode_music_identifier
		{$$ = $1;}
	| lyricmode_repeated_music
		{$$ = $1;}
	| lyricmode_braced_music_list
		{$$ = $1;}
	;

// extra syntax
lyricmode_music_identifier
	: zero_command
		{$$ = $1;}
	| CMD_TIME FRACTION
		{$$ = command($1, $2);}
	| CMD_BAR string
		{$$ = command($1, $2);}
	| CMD_OMIT property_path
		{$$ = command($1, $2);}
	| CMD_OTTAVA property_path
		{$$ = command($1, $2);}
	| CMD_BARNUMBERCHECK scm_identifier
		{$$ = command($1, $2);}
	| CMD_BARNUMBERCHECK unsigned_number
		{$$ = command($1, $2);}
	| CMD_MARK full_markup
		{$$ = command($1, $2);}
	| CMD_SKIP duration
		{$$ = command($1, $2);}
	| CMD_UNFOLDREPEATS lyricmode_music
		{$$ = command($1, $2);}
	| CMD_ONCE music_assign
		{$$ = command($1, $2);}
	| CMD_PARTIAL duration
		{$$ = command($1, $2);}
	| CMD_TUPLETSPAN duration
		{$$ = command($1, $2);}
	| CMD_TUPLETSPAN DEFAULT
		{$$ = command($1, $2);}
	| CMD_TUPLET FRACTION lyricmode_music
		{$$ = command($1, $2, $3);}
	| CMD_TUPLET FRACTION duration lyricmode_music
		{$$ = command($1, $2, $3, $4);}
	| CMD_TWEAK property_path scalar
		{$$ = command($1, $2, $3);}
	| CMD_TIMES FRACTION lyricmode_music
		{$$ = command($1, $2, $3);}
	| CMD_SHAPE scm_identifier symbol
		{$$ = command($1, $2, $3);}
	| CMD_ACCIDENTALSTYLE grob_prop_spec
		{$$ = command($1, $2);}
	| CMD_NUMERICTIMESIGNATURE lyricmode_music_identifier
		{$$ = command($1, $2);}
	| CMD_DEFAULTTIMESIGNATURE
		{$$ = command($1);}
	| CMD_BENDAFTER scm_identifier
		{$$ = command($1, $2);}
	| CMD_COMPOUNDMETER scm_identifier
		{$$ = command($1, $2);}
	;

// extra syntax
lyricmode_repeated_music
	: REPEAT simple_string unsigned_number lyricmode_braced_music_list
		{$$ = command($1, $2, $3, $4);}
	| REPEAT simple_string unsigned_number lyricmode_braced_music_list ALTERNATIVE lyricmode_braced_music_list
		{$$ = command($1, $2, $3, $4, command($5, $6));}
	;

// extra syntax
chordmode_braced_music_list
	: '{' chordmode_music_list '}'
		{$$ = musicBlock($2);}
	;

// extra syntax
chordmode_music_list
	: %empty
		{$$ = [];}
	| chordmode_music_list chordmode_music
		{$$ = $1.concat([$2]);}
	;

// extra syntax
chordmode_music
	: new_chord post_events
		{$$ = briefChord($1, {post_events: $2, locations: [@1, @2]});}
	| music_assign
		{$$ = $1;}
	| chordmode_repeated_music
		{$$ = $1;}
	| chordmode_braced_music_list
		{$$ = $1;}
	;

// extra syntax
chordmode_repeated_music
	: REPEAT simple_string unsigned_number chordmode_braced_music_list
		{$$ = command($1, $2, $3, $4);}
	| REPEAT simple_string unsigned_number chordmode_braced_music_list ALTERNATIVE chordmode_braced_music_list
		{$$ = command($1, $2, $3, $4, command($5, $6));}
	;

mode_changing_head_with_context
	: DRUMS
		{$$ = $1;}
	| FIGURES
		{$$ = $1;}
	| CHORDS
		{$$ = $1;}
	| LYRICS
		{$$ = $1;}
	;

mode_changing_head
	: NOTEMODE
		{$$ = $1;}
	| DRUMMODE
		{$$ = $1;}
	| FIGUREMODE
		{$$ = $1;}
	//| CHORDMODE
	//	{$$ = $1;}
	//| LYRICMODE
	//	{$$ = $1;}
	;

grouped_music_list
	: sequential_music
		{$$ = $1;}
	| simultaneous_music
		{$$ = $1;}
	;

simultaneous_music
	: SIMULTANEOUS braced_music_list
		{$$ = command($1, $2);}
	//| DOUBLE_ANGLE_OPEN music_list DOUBLE_ANGLE_CLOSE
	//	{$$ = simultaneousList($2);}
	| DOUBLE_ANGLE_OPEN multiple_voices_music_list DOUBLE_ANGLE_CLOSE
		{$$ = simultaneousList($2);}
	;

// extra syntax
multiple_voices_music_list
	: music_list
		{$$ = $1;}
	| multiple_voices_music_list E_BACKSLASH music_list
		{$$ = [...$1, $2, ...$3];}
	;

sequential_music
	: SEQUENTIAL braced_music_list
		{$$ = command($2);}
	| braced_music_list
		{$$ = $1;}
	;

braced_music_list
	: '{' music_list '}'
		{$$ = musicBlock($2);}
	;

music_list
	: %empty
		{$$ = [];}
	| music_list music_embedded
		{$$ = $1.concat([$2]); lineRegister(@2, $2);}
	;

music_embedded
	: music
		{$$ = $1;}
	| post_event
		{$$ = $1;}
	| music_embedded_backup
		{$$ = $1;}
	//| music_embedded_backup BACKUP lyric_element_music
	//| duration post_events %prec ':'
	;

music_embedded_backup
	: embedded_scm
		{$$ = $1;}
	;

music
	: music_assign
		{$$ = $1;}
	| pitch_as_music
		{$$ = $1;}
	//| lyric_element_music
	;

// extra syntax
variable_command
	: COMMAND
		{$$ = variable($1);}
	// some test case use \lower as a variable name!?
	| CMD_LOWER
		{$$ = variable($1);}
	;

lyric_element_music
	: lyric_element optional_notemode_duration post_events
		{$$ = lyric($1, {duration: $2, post_events: $3, locations: [@1, @3]});}
	// extra formula
	| variable_command optional_notemode_duration post_events
		{$$ = lyric($1, {duration: $2, post_events: $3, locations: [@1, @3]});}
	;

lyric_element
	: full_markup
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| literal_string
		{$$ = $1;}
	//| LYRIC_ELEMENT
	// extra formula
	| general_text
		{$$ = $1;}
	// extra formula
	| "'"
		{$$ = $1;}
	// extra formula
	| UNSIGNED
		{$$ = $1;}
	// extra formula
	| PITCH
		{$$ = $1;}
	| UNKNOWN_CHAR
		{$$ = $1;}
	;

pitch_as_music
	: pitch_or_music
		{$$ = $1;}
	;

music_assign
	: simple_music
		{$$ = $1;}
	| composite_music
		{$$ = $1;}
	;

simple_music
	: event_chord
		{$$ = $1;}
	| music_property_def
		{$$ = $1;}
	| context_change
		{$$ = $1;}
	// extra formula
	| variable_command
		{$$ = $1;}
	// extra formula
	| COMMAND full_markup
		{$$ = command($1, $2);}
	;

context_change
	: CHANGE symbol '=' simple_string
		{$$ = command($1, assignment($2, $4));}
	;

music_property_def
	: OVERRIDE grob_prop_path '=' scalar
		{$$ = command($1, assignment($2, $4));}
	// extra formula
	| OVERRIDEPROPERTY grob_prop_spec scm_identifier
		{$$ = command($1, $2, $3);}
	//| REVERT simple_revert_context revert_arg
	//	{$$ = command($1, $2, $3);}
	| REVERT revert_arg
		{$$ = command($1, $2);}
	| SET context_prop_spec '=' scalar
		{$$ = command($1, assignment($2, $4));}
	| UNSET context_prop_spec
		{$$ = command($1, $2);}
	;

revert_arg
	//: revert_arg_backup BACKUP symbol_list_arg
	: revert_arg_backup
		{$$ = $1;}
	// extra formula
	| revert_arg_backup symbol_list_arg
		{$$ = [$1, $2];}
	;

revert_arg_backup
	: revert_arg_part
		{$$ = $1;}
	;

revert_arg_part
	: symbol_list_part
		{$$ = $1;}
	| revert_arg_backup '.' symbol_list_part
		{$$ = $1 + "." + $3;}
	//| revert_arg_backup BACKUP SCM_ARG '.' symbol_list_part
	//| revert_arg_backup BACKUP SCM_ARG ',' symbol_list_part
	//| revert_arg_backup BACKUP SCM_ARG symbol_list_part
	;

symbol_list_arg
	: SYMBOL_LIST
		{$$ = $1;}
	| SYMBOL_LIST '.' symbol_list_rev
		{$$ = $1.toString() + $2 + $3.toString();}
	| SYMBOL_LIST ',' symbol_list_rev
		{$$ = $1.toString() + $2 + $3.toString();}
	;

// extra syntax
SYMBOL_LIST
	: symbol_list_part
		{$$ = $1;}
	;

simple_revert_context
	: symbol_list_part
		{$$ = $1;}
	;

grob_prop_path
	: grob_prop_spec
		{$$ = [$1];}
	| grob_prop_spec property_path
		{$$ = [$1, $2];}
	;

grob_prop_spec
	: symbol_list_rev
		{$$ = $1;}
	;

context_prop_spec
	: symbol_list_rev
		{$$ = $1;}
	;

event_chord
	: note_chord_element
		{$$ = $1;}
	| tempo_event
		{$$ = $1;}
	| simple_element post_events
		{$$ = rest({...$1, post_events: $2, locations: [@1, @2]});}
	//| CHORD_REPETITION optional_notemode_duration post_events
	//| MULTI_MEASURE_REST optional_notemode_duration post_events
	;

tempo_event
	: TEMPO steno_duration '=' tempo_range
		//{$$ = {tempo: $4, unit: $2};}
		{$$ = tempo($4, $2);}
	| TEMPO text steno_duration '=' tempo_range
		//{$$ = {tempo: $5, unit: $3, text: $2};}
		{$$ = tempo($5, $3, $2);}
	| TEMPO text
		{$$ = tempo(undefined, undefined, $2);}
	| TEMPO CMD_TEMPOLEGEND
		{$$ = tempo(undefined, undefined, $2);}
	;

tempo_range
	: unsigned_number
		{$$ = $1;}
	| unsigned_number '-' unsigned_number
		{$$ = {from: $1, to: $2};}
	;

simple_element
	//: DRUM_PITCH optional_notemode_duration
	: RESTNAME optional_notemode_duration
		{$$ = {name: $1, duration: $2};}
	;

optional_notemode_duration
	: %empty
		{$$ = null;}
	| duration
		{$$ = $1;}
	;

duration
	: steno_duration multipliers
		//{$$ = $1 + $2;}
		{$$ = duration({...$1, multipliers: $2});}
	;

steno_duration
	: unsigned_number dots
		//{$$ = $1 + $2;}
		{$$ = duration({number: $1, dots: $2.length});}
	| DURATION_IDENTIFIER dots
		{$$ = duration({number: $1, dots: $2.length});}
	;

DURATION_IDENTIFIER
	: CMD_BREVE
		{$$ = $1;}
	| CMD_LONGA
		{$$ = $1;}
	;

dots
	: %empty
		{$$ = "";}
	| dots dot
		{$$ = $1 + $2;}
	;

multipliers
	: %empty
		{$$ = [];}
	| multipliers '*' unsigned_number
		{$$ = [...$1, $3];}
	| multipliers '*' FRACTION
		{$$ = [...$1, $3];}
	//| multipliers '*' multiplier_scm
	;

repeated_music
	: REPEAT simple_string unsigned_number music
		{$$ = command($1, $2, $3, $4);}
	| REPEAT simple_string unsigned_number music ALTERNATIVE braced_music_list
		{$$ = command($1, $2, $3, $4, command($5, $6));}
	;

unsigned_number
	: UNSIGNED
		{$$ = $1;}
	//| POST_UNSIGNED
	//	{$$ = $1;}
	//| NUMBER_IDENTIFIER
	//| embedded_scm
	;

simple_string
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	;

// all kinds commands in music list, seems named as MUSIC_IDENTIFIER in lilypond's parser.yy
music_identifier
	: zero_command
		{$$ = $1;}
	| CMD_CLEF string
		{$$ = command($1, $2);}
	| CMD_TIME FRACTION
		{$$ = command($1, $2);}
	| CMD_BAR string
		{$$ = command($1, $2);}
	| CMD_OMIT property_path
		{$$ = command($1, $2);}
	| CMD_OTTAVA property_path
		{$$ = command($1, $2);}
	| CMD_BARNUMBERCHECK scm_identifier
		{$$ = command($1, $2);}
	| CMD_BARNUMBERCHECK unsigned_number
		{$$ = command($1, $2);}
	| CMD_MARK full_markup
		{$$ = command($1, $2);}
	// TODO:
	| CMD_INCLUDE string
		{$$ = command($1, $2);}
	| CMD_SKIP duration
		{$$ = command($1, $2);}
	//| CMD_PARENTHESIZE property_path
	//	{$$ = command($1, $2);}
	| CMD_UNFOLDREPEATS music
		{$$ = command($1, $2);}
	| CMD_GRACE music
		{$$ = command($1, $2);}
	| CMD_ACCIACCATURA music
		{$$ = command($1, $2);}
	| CMD_APPOGGIATURA music
		{$$ = command($1, $2);}
	| CMD_SLASHEDGRACE music
		{$$ = command($1, $2);}
	| CMD_LANGUAGE string
		{$$ = command($1, $2);}
	| CMD_ONCE music_assign
		{$$ = command($1, $2);}
	| CMD_PARTIAL duration
		{$$ = command($1, $2);}
	| CMD_TUPLETSPAN duration
		{$$ = command($1, $2);}
	| CMD_TUPLETSPAN DEFAULT
		{$$ = command($1, $2);}
	| CMD_TUPLET FRACTION music
		{$$ = command($1, $2, $3);}
	| CMD_TUPLET FRACTION duration music
		{$$ = command($1, $2, $3, $4);}
	| CMD_TWEAK property_path scalar
		{$$ = command($1, $2, $3);}
	| CMD_KEY PITCH COMMAND
		{$$ = command($1, $2, $3);}
	| CMD_TIMES FRACTION music
		{$$ = command($1, $2, $3);}
	| CMD_AFTERGRACE music music
		{$$ = command($1, $2, $3);}
	| CMD_PARALLELMUSIC scm_identifier composite_music
		{$$ = command($1, $2, $3);}
	| CMD_SHAPE scm_identifier symbol
		{$$ = command($1, $2, $3);}
	| CMD_ACCIDENTALSTYLE grob_prop_spec
		{$$ = command($1, $2);}
	| CMD_NUMERICTIMESIGNATURE music_identifier
		{$$ = command($1, $2);}
	| CMD_DEFAULTTIMESIGNATURE
		{$$ = command($1);}
	| CMD_BENDAFTER scm_identifier
		{$$ = command($1, $2);}
	| CMD_COMPOUNDMETER scm_identifier
		{$$ = command($1, $2);}
	| CMD_TRANSPOSITION pitch
		{$$ = command($1, chordElem($2, {locations: [@2, @2]}));}
	| CMD_ABSOLUTE music
		{$$ = command($1, $2);}
	| CMD_HIDE symbol
		{$$ = command($1, $2);}
	| CMD_CROSSSTAFF composite_music
		{$$ = command($1, $2);}
	| CMD_KEEPWITHTAG symbol
		{$$ = command($1, $2);}
	| CMD_TAG symbol composite_music
		{$$ = command($1, $2, $3);}
	| CMD_SCALEDURATIONS FRACTION composite_music
		{$$ = command($1, $2, $3);}
	| CMD_TUPLETNEUTRAL music
		{$$ = command($1, $2);}
	| CMD_ARTICULATE music
		{$$ = command($1, $2);}
	| markup_font_size music
		{$$ = command($1, $2);}
	| pitch_mode_music
		{$$ = $1;}
	| "("
		{$$ = $1;}
	| ")"
		{$$ = $1;}
	| "["
		{$$ = $1;}
	| "]"
		{$$ = $1;}
	| DIVIDE
		{$$ = {proto: "Divide"};}
	| expressive_mark
		{$$ = $1;}
	;

// extra syntax
zero_command
	: CMD_FERMATA
		{$$ = command($1);}
	| CMD_STEMUP
		{$$ = command($1);}
	| CMD_STEMDOWN
		{$$ = command($1);}
	| CMD_STEMNEUTRAL
		{$$ = command($1);}
	| CMD_MERGEDIFFERENTLYDOTTEDON
		{$$ = command($1);}
	| CMD_MERGEDIFFERENTLYHEADEDON
		{$$ = command($1);}
	| CMD_VOICE_NUMBER
		{$$ = command($1);}
	| CMD_SCORE
		{$$ = command($1);}
	| CMD_VOICE
		{$$ = command($1);}
	| CMD_STAFF
		{$$ = command($1);}
	| CMD_PIANOSTAFF
		{$$ = command($1);}
	| CMD_ARPEGGIO
		{$$ = command($1);}
	| CMD_ARPEGGIOARROWDOWN
		{$$ = command($1);}
	| CMD_ARPEGGIOARROWUP
		{$$ = command($1);}
	| CMD_ARPEGGIONORMAL
		{$$ = command($1);}
	| CMD_ARPEGGIOBRACKET
		{$$ = command($1);}
	| CMD_ARPEGGIOPARENTHESIS
		{$$ = command($1);}
	| CMD_ARPEGGIOPARENTHESISDASHED
		{$$ = command($1);}
	| CMD_GLISSANDO
		{$$ = command($1);}
	| CMD_MORDENT
		{$$ = command($1);}
	| CMD_POWERCHORDS
		{$$ = command($1);}
	| CMD_PRALL
		{$$ = command($1);}
	//| CMD_SUSTAINOFF
	//	{$$ = command($1);}
	//| CMD_SUSTAINON
	//	{$$ = command($1);}
	| CMD_TRILL
		{$$ = command($1);}
	| CMD_TURN
		{$$ = command($1);}
	| CMD_POINTANDCLICKOFF
		{$$ = command($1);}
	| CMD_UPBOW
		{$$ = command($1);}
	| CMD_DOWNBOW
		{$$ = command($1);}
	| CMD_BREATHE
		{$$ = command($1);}
	| CMD_STARTTEXTSPAN
		{$$ = command($1);}
	| CMD_STOPTEXTSPAN
		{$$ = command($1);}
	| CMD_FLAGEOLET
		{$$ = command($1);}
	| CMD_SLURDASHED
		{$$ = command($1);}
	| CMD_SLURSOLID
		{$$ = command($1);}
	| CMD_BREAK
		{$$ = command($1);}
	| CMD_PAGEBREAK
		{$$ = command($1);}
	| CMD_STARTTRILLSPAN
		{$$ = command($1);}
	| CMD_STOPTRILLSPAN
		{$$ = command($1);}
	| CMD_CADENZAON
		{$$ = command($1);}
	| CMD_CADENZAOFF
		{$$ = command($1);}
	| CMD_CRESC
		{$$ = command($1);}
	| CMD_CRESCTEXTCRESC
		{$$ = command($1);}
	| CMD_CRESCHAIRPIN
		{$$ = command($1);}
	| CMD_DIM
		{$$ = command($1);}
	| CMD_DIMTEXTDIM
		{$$ = command($1);}
	| CMD_DYNAMICUP
		{$$ = command($1);}
	| CMD_HIDENOTES
		{$$ = command($1);}
	| CMD_UNHIDENOTES
		{$$ = command($1);}
	| CMD_NEWSPACINGSECTION
		{$$ = command($1);}
	| CMD_NOBEAM
		{$$ = command($1);}
	| CMD_ONEVOICE
		{$$ = command($1);}
	| CMD_PHRASINGSLURDOWN
		{$$ = command($1);}
	| CMD_PHRASINGSLURNEUTRAL
		{$$ = command($1);}
	| CMD_PHRASINGSLURUP
		{$$ = command($1);}
	| CMD_SLURDOWN
		{$$ = command($1);}
	| CMD_SLURNEUTRAL
		{$$ = command($1);}
	| CMD_SLURUP
		{$$ = command($1);}
	| CMD_TIEDOWN
		{$$ = command($1);}
	| CMD_TIENEUTRAL
		{$$ = command($1);}
	| CMD_TIEUP
		{$$ = command($1);}
	| CMD_PARENTHESIZE
		{$$ = command($1);}
	| CMD_TUPLETUP
		{$$ = command($1);}
	| CMD_TUPLETDOWN
		{$$ = command($1);}
	| CMD_SHIFTON
		{$$ = command($1);}
	| CMD_REPEATTIE
		{$$ = command($1);}
	;

// extra syntax
expressive_mark
	: CMD_CRESCENDO_BEGIN
		{$$ = $1;}
	| CMD_DECRESCENDO_BEGIN
		{$$ = $1;}
	| CMD_DYNAMICS_END
		{$$ = $1;}
	| CMD_FERMATA
		{$$ = $1;}
	| CMD_TWEAK property_path scalar
		{$$ = command($1, $2, $3);}
	| CMD_BENDAFTER scm_identifier
		{$$ = command($1, $2);}
	| CMD_DYNAMIC_MARKINGS
		{$$ = command($1);}
	| CMD_MARCATO
		{$$ = command($1);}
	| CMD_STOPPED
		{$$ = command($1);}
	| CMD_TENUTO
		{$$ = command($1);}
	| CMD_STACCATISSIMO
		{$$ = command($1);}
	| CMD_ACCENT
		{$$ = command($1);}
	| CMD_STACCATO
		{$$ = command($1);}
	| CMD_PORTATO
		{$$ = command($1);}
	| CMD_MORDENT
		{$$ = command($1);}
	| CMD_PRALL
		{$$ = command($1);}
	| CMD_TURN
		{$$ = command($1);}
	| CMD_ARPEGGIO
		{$$ = command($1);}
	| CMD_TRILL
		{$$ = command($1);}
	| CMD_STARTTRILLSPAN
		{$$ = command($1);}
	| CMD_STOPTRILLSPAN
		{$$ = command($1);}
	| "~"
		{$$ = $1;}
	| "("
		{$$ = $1;}
	| ")"
		{$$ = $1;}
	| "\("
		{$$ = $1;}
	| "\)"
		{$$ = $1;}
	;

// extra syntax
pitch_mode_music
	: CMD_RELATIVE pitch music
		{$$ = command($1, chordElem($2, {locations: [@2, @2]}), $3);}
	| CMD_RELATIVE music
		{$$ = command($1, $2);}
	;

pitch_or_music
	//: pitch exclamations questions octave_check maybe_notemode_duration erroneous_quotes optional_rest post_events
	: pitch exclamations questions optional_notemode_duration optional_rest post_events
		{$$ = chord([chordElem($1, {locations: [@1, @1]})], $4, {exclamations: $2, questions: $3, rest: $5, post_events: $6, locations: [@1, @6]});}
	//| new_chord post_events
	//	{$$ = briefChord($1, {post_events: $2});}
	;

new_chord
	//: steno_tonic_pitch maybe_notemode_duration
	: pitch optional_notemode_duration
		{$$ = {pitch: $1, duration: $2};}
	//| steno_tonic_pitch optional_notemode_duration chord_separator chord_items
	| pitch optional_notemode_duration chord_separator chord_items
		{$$ = {pitch: $1, duration: $2, separator: $3, items: $4};}
	;

chord_items
	: %empty
		{$$ = [];}
	| chord_items chord_item
		{$$ = $1.concat($2);}
	;

chord_item
	: chord_separator
		{$$ = $1;}
	| step_numbers
		{$$ = $1;}
	| CHORD_MODIFIER
		{$$ = $1;}
	;

// m, m7, dim, dim7, aug, maj, maj7
CHORD_MODIFIER
	: CHORD_MODIFIER_WORD
		{$$ = $1;}
	//| CHORD_MODIFIER_WORD UNSIGNED
	//	{$$ = $1 + $2;}
	;

step_numbers
	: step_number
		{$$ = $1;}
	| step_numbers dot step_number
		{$$ = $1 + $2 + $3;}
	;

step_number
	: UNSIGNED
		{$$ = $1;}
	| UNSIGNED '+'
		{$$ = $1 + $2;}
	| UNSIGNED CHORD_MINUS
		{$$ = $1 + $2;}
	;

maybe_notemode_duration
	: %empty
		{$$ = null;}
	| duration
		{$$ = $1;}
	;

steno_tonic_pitch
	: TONICNAME_PITCH quotes
		{$$ = $1 + $2;}
	;

CHORD_BASS
	: "/" "+"
		{$$ = $1 + $2;}
	;

CHORD_CARET
	: "^"
		{$$ = $1;}
	;

CHORD_COLON
	: ":"
		{$$ = $1;}
	;

CHORD_MINUS
	: "-"
		{$$ = $1;}
	;

CHORD_SLASH
	: "/"
		{$$ = $1;}
	;

chord_separator
	: CHORD_COLON
		{$$ = $1;}
	| CHORD_CARET
		{$$ = $1;}
	//| CHORD_SLASH steno_tonic_pitch
	| CHORD_SLASH pitch
		{$$ = $1 + $2;}
	//| CHORD_BASS steno_tonic_pitch
	| CHORD_BASS pitch
		{$$ = $1 + $2;}
	;

exclamations
	: %empty
		{$$ = [];}
	| exclamations '!'
		{$$ = $1.concat($2);}
	;

questions
	: %empty
		{$$ = [];}
	| questions '?'
		{$$ = $1.concat($2);}
	;

post_events
	: %empty
		{$$ = [];}
	| post_events post_event
		{$$ = $1.concat($2);}
	;

note_chord_element
	: chord_body optional_notemode_duration post_events
		{$$ = chord($1, $2, {withAngle: true, post_events: $3, locations: [@1, @2]});}
	;

chord_body
	: "<" chord_body_elements ">"
		{$$ = $2;}
	//| FIGURE_OPEN figure_list FIGURE_CLOSE
	;

chord_body_elements
	: %empty
		{$$ = [];}
	| chord_body_elements chord_body_element
		{$$ = $1.concat([$2]);}
	;

chord_body_element
	//: pitch_or_tonic_pitch exclamations questions octave_check post_events %prec ':'
	: pitch_or_tonic_pitch exclamations questions post_events
		//{$$ = $1 + $2 + $3 + $4;}
		{$$ = chordElem($1, {locations: [@1, @4], exclamations: $2, questions: $3, post_events: $4});}
	//| DRUM_PITCH post_events %prec ':' 
	| music_function_chord_body
		{$$ = $1;}
	//| post_event
	;

music_function_chord_body
	//: music_function_call
	//| MUSIC_IDENTIFIER
	//| embedded_scm
	: music_identifier
		{$$ = $1;}
	;

pitch_or_tonic_pitch
	: pitch
		{$$ = $1;}
	//| steno_tonic_pitch
	;

/*// extra syntax
pitches
	:	pitches pitch
		{$$ = $1.concat([$2]);}
	|	pitch
		{$$ = [$1];}
	;*/

pitch
	: PITCH quotes
		{$$ = $1 + $2;}
	//| steno_pitch
	// extra formula
	//| PLACEHOLDER_PITCH
	//	{$$ = $1;}
	;

quotes
	: %empty
		{$$ = "";}
	| sub_quotes
		{$$ = $1;}
	| sup_quotes
		{$$ = $1;}
	;

sup_quotes
	: "'"
		{$$ = $1;}
	| sup_quotes "'"
		{$$ = $1 + $2;}
	;

sub_quotes
	: ","
		{$$ = $1;}
	| sub_quotes ","
		{$$ = $1 + $2;}
	;

post_event
	: post_event_nofinger
		{$$ = $1;}
	| '-' fingering
		//{$$ = {type: "fingering", direction: "middle", value: $2};}
		{$$ = postEvent("middle", fingering($2));}
	;

HYPHEN
	: PRE_HYPHEN "-"
		{$$ = "--";}
	| PRE_HYPHEN PRE_HYPHEN
		{$$ = "--";}
	;

EXTENDER
	: PRE_EXTENDER "_"
		{$$ = "__";}
	| PRE_EXTENDER PRE_EXTENDER
		{$$ = "__";}
	;

post_event_nofinger
	: '^' fingering
		//{$$ = {direction: "up", fingering: $2};}
		{$$ = postEvent("up", fingering($2));}
	| '_' fingering
		//{$$ = {direction: "down", fingering: $2};}
		{$$ = postEvent("down", fingering($2));}
	| direction_less_event
		{$$ = $1;}
	| script_dir music_function_call
		{$$ = postEvent($1, $2);}
	| HYPHEN
		{$$ = $1;}
	| EXTENDER
		{$$ = $1;}
	| script_dir direction_reqd_event
		{$$ = postEvent($1, $2);}
	| script_dir direction_less_event
		{$$ = postEvent($1, $2);}
	// extra formula
	| script_dir zero_command
		{$$ = postEvent($1, $2);}
	// extra formula
	| script_dir expressive_mark
		{$$ = postEvent($1, $2);}
	// extra formula
	| expressive_mark
		{$$ = postEvent(null, $1);}
	// extra formula
	| CMD_SUSTAINOFF
		{$$ = postEvent(null, $1);}
	// extra formula
	| CMD_SUSTAINON
		{$$ = postEvent(null, $1);}
	// extra formula
	| "["
		{$$ = $1;}
	// extra formula
	| "]"
		{$$ = $1;}
	// extra formula
	| script_dir "["
		{$$ = postEvent($1, $2);}
	// extra formula
	| script_dir "]"
		{$$ = postEvent($1, $2);}
	// extra formula
	| "("
		{$$ = $1;}
	// extra formula
	| ")"
		{$$ = $1;}
	// extra formula
	| script_dir variable_command
		{$$ = postEvent($1, $2);}
	;

direction_reqd_event
	: gen_text_def
		{$$ = $1;}
	| script_abbreviation
		{$$ = $1;}
	;

gen_text_def
	: full_markup
		{$$ = $1;}
	| literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| embedded_scm
		{$$ = $1;}
	;

script_abbreviation
	: '^'
		{$$ = $1;}
	| '+'
		{$$ = $1;}
	| '-' 
		{$$ = $1;}
 	| '!'
		{$$ = $1;}
	| '>'
		{$$ = $1;}
	| dot
		{$$ = $1;}
	| '_'
		{$$ = $1;}
	;

direction_less_event
	: string_number_event
		{$$ = $1;}
	//| EVENT_IDENTIFIER
	| tremolo_type
		{$$ = $1;}
	| event_function_event
		{$$ = $1;}
	;

string_number_event
	: E_UNSIGNED
		{$$ = $1;}
	;

tremolo_type
	: ':'
		{$$ = ":";}
	| ':' UNSIGNED
		{$$ = ":" + $2;}
	;

event_function_event
	: EVENT_FUNCTION function_arglist
	;

music_function_call
	: MUSIC_FUNCTION function_arglist
	;

script_dir
	: "_"
		{$$ = "down";}
	| "^"
		{$$ = "up";}
	| "-"
		{$$ = "middle";}
	;

fingering
	: UNSIGNED
		{$$ = $1;}
	;

full_markup
	: markup_mode markup_top
		{$$ = command($1, ...$2);}
	| markup_mode_word
		{$$ = $1;}
	;

markup_mode
	: MARKUP
		{$$ = $1;}
	;

markup_top
	: markup_list
		{$$ = $1;}
	| markup_head_1_list simple_markup
		//{$$ = {head: $1, body: $2};}
		{$$ = $1.concat([$2]);}
	| simple_markup_noword
		{$$ = [$1];}
	;

markup_mode_word
	: markup_mode markup_word
		{$$ = command($1, $2);}
	;

output_def
	: output_def_body '}'
		{$$ = $1;}
	;

output_def_body
	: output_def_head_with_mode_switch '{'
		{$$ = block("score", $1);}
	| output_def_body assignment
		{
			$1.body.push($2);
			$$ = $1;
		}
	| output_def_body music_or_context_def
		{
			$1.body.push($2);
			$$ = $1;
		}
	| output_def_body scm_identifier
		{
			$1.body.push($2);
			$$ = $1;
		}
	//| output_def_body embedded_scm_active
	//| output_def_body SCM_TOKEN
	//| output_def_body error
	;

output_def_head_with_mode_switch
	: output_def_head
		{$$ = $1;}
	;

output_def_head
	: PAPER
		{$$ = $1;}
	| MIDI
		{$$ = $1;}
	| LAYOUT
		{$$ = $1;}
	;

music_or_context_def
	: music_assign
		{$$ = $1;}
	| context_def_spec_block
		{$$ = $1;}
	;

context_def_spec_block
	: CONTEXT '{' context_def_spec_body '}'
		{$$ = block("context", $1, $3);}
	;

context_def_spec_body
	: %empty
		{$$ = [];}
	| context_def_spec_body context_mod
		{$$ = $1.concat([$2]);}
	| context_def_spec_body context_modification
		{$$ = $1.concat([$2]);}
	| context_def_spec_body context_mod_arg
		{$$ = $1.concat([$2]);}
	;

context_mod_arg
	: embedded_scm
		{$$ = $1;}
	| composite_music
		{$$ = $1;}
	;

context_modification
	: WITH '{' context_mod_list '}'
		{$$ = command($1, inlineBlock($3));}
	| WITH context_modification_arg
		{$$ = command($1, $2);}
	;

context_modification_arg
	: embedded_scm
		{$$ = $1;}
	//| MUSIC_IDENTIFIER
	| music_identifier
		{$$ = $1;}
	;

context_mod_list
	: %empty
		{$$ = [];}
	| context_mod_list context_mod
		{$$ = $1.concat($2);}
	| context_mod_list context_mod_arg
		{$$ = $1.concat($2);}
	;

context_mod
	: property_operation
		{$$ = $1;}
	//| context_def_mod SYMBOL
	| context_def_mod symbol
		{$$ = command($1, $2);}
	//| context_def_mod embedded_scm
	;

property_operation
	: symbol '=' scalar
		{$$ = assignment($1, $3);}
	| UNSET symbol
		{$$ = command($1, $2);}
	| OVERRIDE revert_arg '=' scalar
		{$$ = command($1, assignment($2, $4));}
	| REVERT revert_arg
		{$$ = command($1, $2);}
	;

symbol
	: literal_string
		{$$ = $1;}
	| SYMBOL
		{$$ = $1;}
	| embedded_scm_bare
		{$$ = $1;}
	;

scalar
	//: embedded_scm_arg
	: pitch_or_music
		{$$ = $1;}
	| scm_identifier
		{$$ = $1;}
	| bare_number
		{$$ = $1;}
	| '-' bare_number
		{$$ = -$1;}
	| string
		{$$ = $1;}
	| symbol_list_part_bare '.' property_path
		{$$ = $1 + "." + $3;}
	| symbol_list_part_bare ',' property_path
		{$$ = $1 + "," + $3;}
	// extra formula
	| UNSIGNED ',' property_path
		{$$ = $1 + "," + $3;}
	// extra formula
	| COMMAND
		{$$ = $1;}
	;

bare_number
	: bare_number_common
		{$$ = $1;}
	| UNSIGNED
		{$$ = Number($1);}
	//| UNSIGNED NUMBER_IDENTIFIER
	;

context_def_mod
	: CONSISTS
		{$$ = $1;}
	| REMOVE
		{$$ = $1;}
	| ACCEPTS
		{$$ = $1;}
	| DEFAULTCHILD
		{$$ = $1;}
	| DENIES
		{$$ = $1;}
	| ALIAS
		{$$ = $1;}
	| TYPE
		{$$ = $1;}
	| DESCRIPTION
		{$$ = $1;}
	| NAME
		{$$ = $1;}
	;

embedded_scm_active
	//: SCM_IDENTIFIER
	: scm_identifier
		{$$ = $1;}
	| scm_function_call
		{$$ = $1;}
	| lookup
		{$$ = $1;}
	;


/*// extra syntax, maybe the substitution for embedded_scm_active in lilypond's parser
embedded_scheme_expression
	: "#" scheme_expression
		{$$ = scheme($2);}
	;*/

// extra syntax
scheme_expression
	: SCM_TRUE
		{$$ = true;}
	| SCM_FALSE
		{$$ = false;}
	| SCM_HEX
		{$$ = $1}
	| SCM_COLON
		{$$ = $1}
	| bare_number
		{$$ = $1;}
	| INT
		{$$ = $1;}
	| "(" ")"
		{$$ = null;}
	| "+" "inf.0"
		{$$ = $1 + $2;}
	| "-" "inf.0"
		{$$ = $1 + $2;}
	| "(" scheme_expression "." scheme_expression ")"
		{$$ = schemePair($2, $4);}
	| "(" scheme_expression scheme_args ")"
		{$$ = schemeFunction($2, $3);}
	| scheme_token
		{$$ = $1;}
	| scheme_token "?"
		{$$ = $1 + $2;}
	| "'" scheme_expression
		{$$ = schemePointer($2);}
	| "`" scheme_expression
		{$$ = schemePointer($2);}
	| "#" "{" lilypond "#" "}"
		{$$ = schemeEmbed($3);}
	| "*"
		{$$ = $1;}
	;

scheme_args
	: %empty
		{$$ = [];}
	| scheme_args scheme_expression
		{$$ = $1.concat($2);}
	;

scheme_token
	: bare_number
		{$$ = $1;}
	| symbol
		{$$ = $1;}
	| symbol ":" scheme_token
		{$$ = $1 + $2 + $3;}
	| symbol ":" ":" scheme_token
		{$$ = $1 + $2 + $3 + $4;}
	;

optional_rest
	: %empty
		{$$ = null;}
	| REST
		{$$ = $1;}
	;

// extra syntax, the substitution of STRING
literal_string
	: STRING
		{$$ = string($1);}
	;
"}}]);
+//# sourceMappingURL=chunk-2d0db258.a4804a7a.js.map

dist/js/chunk-40965e1a.74707226.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-40965e1a"],{"00fd":function(t,e,s){var o=s("9e69"),a=Object.prototype,i=a.hasOwnProperty,n=a.toString,r=o?o.toStringTag:void 0;function c(t){var e=i.call(t,r),s=t[r];try{t[r]=void 0;var o=!0}catch(c){}var a=n.call(t);return o&&(e?t[r]=s:delete t[r]),a}t.exports=c},"0146":function(t,e,s){var o=s("24fb");e=o(!1),e.push([t.i,'@font-face{font-family:lotus-music;src:url(data:application/font-woff;charset=utf-8;base64,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) format("woff");font-weight:400;font-style:normal}',""]),t.exports=e},1310:function(t,e){function s(t){return null!=t&&"object"==typeof t}t.exports=s},"1a8c":function(t,e){function s(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}t.exports=s},"1c3a":function(t,e,s){"use strict";s.d(e,"b",(function(){return h})),s.d(e,"a",(function(){return u}));var o=s("2b0e"),a=s("a139"),i=s("f7ce"),n=s("1f25");const r=o["a"].extend(a["a"]),c=o["a"].extend(i["a"]),l=async(t,e)=>{const s="data:image/svg+xml,"+encodeURIComponent(n["h"]+t),o=await new Promise((t,e)=>{const o=new Image;o.onload=()=>t(o),o.onerror=t=>{console.warn("Error when loading svg image:",s),e(t)},o.src=s});e.width=o.width,e.height=o.height;const a=e.getContext("2d");a.drawImage(o,0,0);const i=await new Promise(t=>e.toBlob(e=>t(e),"image/png"));return URL.createObjectURL(i)},d=(t,e,s)=>{const o=(new DOMParser).parseFromString(t,"text/xml"),a=o.childNodes[0];for(const n of a.childNodes)switch(n.tagName){case"text":/www\.lilypond\.org/.test(n.textContent)&&a.removeChild(n);break;case"a":const t=n.getAttribute("xlink:href"),s=t.match(/:(\d+:\d+:\d+)$/);if(s){const t=s[1];e.has(t)&&a.removeChild(n)}break}const i=a.outerHTML;return l(i,s)},h=async(t,e,s)=>{const o=[];for(const a of t)o.push(await d(a,e,s));return o},f=(t,e)=>{for(const s of t.children)if("use"===s.tagName){const o=s.getAttribute("xlink:href");if(o){const a=o.substr(1),i=e[a];if(i){const e=i.cloneNode(!0);e.classList.add(...s.classList),(e.classList.contains("staff-line")||e.classList.contains("line")||e.classList.contains("slur"))&&e.children[0].setAttribute("stroke","black"),t.insertBefore(e,s),t.removeChild(s)}}}else f(s,e)},u=async function*({sheetDocument:t,signs:e,hashTable:s,matchedIds:o,canvas:a}){console.assert(!!t,"sheetDocument is null."),console.assert(!!o,"matchedIds is null."),console.assert(!!a,"canvas is null."),console.assert(e||s,"signs & hashTable is both null.");const i=new r({propsData:{doc:t,partialVisible:!1}}).$mount(document.createElement("div"));await i.$nextTick(),e||(e=new c({propsData:{hashTable:s}}).$mount(document.createElement("div")));const n=e.$el.children[0],d=[...n.children].reduce((t,e)=>(t[e.id]=e,t),{}),h=[...i.$el.children];for(const r of h)o.forEach(t=>{r.querySelectorAll(`g[data-href='${t}']`).forEach(t=>t.parentElement.removeChild(t))}),f(r,d),yield await l(r.outerHTML,a)}},2462:function(t,e,s){var o=s("6df9");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("6677ab5e",o,!0,{sourceMap:!1,shadowMode:!1})},"29f3":function(t,e){var s=Object.prototype,o=s.toString;function a(t){return o.call(t)}t.exports=a},"2b3e":function(t,e,s){var o=s("585a"),a="object"==typeof self&&self&&self.Object===Object&&self,i=o||a||Function("return this")();t.exports=i},"2be7":function(t,e,s){var o=s("24fb"),a=s("0146");e=o(!1),e.i(a),e.push([t.i,"",""]),t.exports=e},"2bff":function(t,e,s){var o=s("2be7");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("1b71e8f0",o,!0,{sourceMap:!1,shadowMode:!1})},3729:function(t,e,s){var o=s("9e69"),a=s("00fd"),i=s("29f3"),n="[object Null]",r="[object Undefined]",c=o?o.toStringTag:void 0;function l(t){return null==t?void 0===t?r:n:c&&c in Object(t)?a(t):i(t)}t.exports=l},"3ed0":function(t,e,s){var o=s("24fb");e=o(!1),e.push([t.i,":root{--lotus-token-default-color:#000;--lotus-token-on-color:#0af}",""]),t.exports=e},"408c":function(t,e,s){var o=s("2b3e"),a=function(){return o.Date.now()};t.exports=a},"4a93":function(t,e,s){"use strict";s("f7f3")},"4cef":function(t,e){var s=/\s/;function o(t){var e=t.length;while(e--&&s.test(t.charAt(e)));return e}t.exports=o},"50f4":function(t,e,s){"use strict";s("8b2a")},"585a":function(t,e,s){(function(e){var s="object"==typeof e&&e&&e.Object===Object&&e;t.exports=s}).call(this,s("c8ba"))},"5f3d":function(t,e,s){var o=s("b1a2");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("0a968266",o,!0,{sourceMap:!1,shadowMode:!1})},"6c07":function(t,e,s){var o=s("81d1");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("2c493a70",o,!0,{sourceMap:!1,shadowMode:!1})},"6c11":function(t,e,s){"use strict";s("2bff")},"6df9":function(t,e,s){var o=s("24fb"),a=s("3ed0");e=o(!1),e.i(a),e.push([t.i,".token .line[data-v-5fc078a1],.token .slur[data-v-5fc078a1],.token .staff-line[data-v-5fc078a1]{stroke:var(--lotus-token-default-color)}.token use[data-v-5fc078a1]{fill:var(--lotus-token-default-color)}.token.matched use.on[data-v-5fc078a1]{fill:var(--lotus-token-on-color);stroke-width:.1;stroke:var(--lotus-token-on-color)}",""]),t.exports=e},"81d1":function(t,e,s){var o=s("24fb");e=o(!1),e.push([t.i,".check-button[data-v-58f51ec2]{cursor:pointer}",""]),t.exports=e},"8a81":function(t,e,s){"use strict";s("6c07")},"8b2a":function(t,e,s){var o=s("b1f3");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("715033e0",o,!0,{sourceMap:!1,shadowMode:!1})},"8d74":function(t,e,s){var o=s("4cef"),a=/^\s+/;function i(t){return t?t.slice(0,o(t)+1).replace(a,""):t}t.exports=i},"9e69":function(t,e,s){var o=s("2b3e"),a=o.Symbol;t.exports=a},a139:function(t,e,s){"use strict";var o=function(){var t=this,e=t._self._c;return e("div",{staticClass:"sheet live"},t._l(t.shownPages,(function(s,o){return e("svg",{key:o,ref:"pages",refInFor:!0,staticClass:"page",style:{["background-image"]:t.backgroundImages&&t.backgroundImages[o]&&`url(${t.backgroundImages[o]})`},attrs:{xmlns:"http://www.w3.org/2000/svg",width:s.width,height:s.height,viewBox:`${s.viewBox.x} ${s.viewBox.y} ${s.viewBox.width} ${s.viewBox.height}`},on:{DOMNodeInserted:t.onPageChanged}},[t.partialVisible&&s.hidden?t._e():e("g",[t.showMark?e("g",{staticClass:"mark"},[t._l(s.systems,(function(o,a){return e("g",{key:a,staticClass:"system",attrs:{transform:`translate(${o.x}, ${o.y})`},on:{mousemove:function(e){t.enablePointer&&t.onMousemovePad(o,e)},mouseleave:function(e){t.enablePointer&&t.onMouseleavePad(o,e)},click:function(e){return t.onClickPad(o,e)}}},[e("rect",{attrs:{x:0,y:o.top,width:o.width,height:o.bottom-o.top}}),t._t("system",null,{system:o,page:s})],2)})),t._t("page",null,{page:s})],2):t._e(),t.bakingMode?t._e():e("g",[t.watermark?e("g",{staticClass:"wm"},[e("image",{attrs:{href:t.watermark,x:(t.doc.pageSize.width-t.watermarkSize.width)/2/t.svgScale,y:(t.doc.pageSize.height-t.watermarkSize.height)/2/t.svgScale,width:t.watermarkSize.width/2/t.svgScale,height:t.watermarkSize.height/2/t.svgScale}})]):t._e(),e("g",{staticClass:"page-tokens"},t._l(s.tokens,(function(t,s){return e("SheetToken",{key:s,attrs:{token:t}})})),1),t._l(s.systems,(function(o,a){return e("g",{key:a,staticClass:"system",attrs:{transform:`translate(${o.x}, ${o.y})`}},[t.showCursor&&t.cursorPosition&&t.cursorPosition.system===o.index?e("rect",{staticClass:"cursor",attrs:{x:t.cursorPosition.x,y:o.top-.5,width:"1",height:o.bottom-o.top+1}}):t._e(),e("g",t._l(o.tokens,(function(t,s){return e("SheetToken",{key:s,attrs:{token:t}})})),1),t._l(o.staves,(function(a,i){return e("g",{key:i,staticClass:"staff",attrs:{transform:`translate(${a.x}, ${a.y})`}},[e("g",t._l(a.tokens,(function(t,s){return e("SheetToken",{key:s,attrs:{token:t}})})),1),t._l(a.measures,(function(s,o){return e("g",{key:o,staticClass:"measure"},t._l(s.tokens,(function(s,o){return e("SheetToken",{key:o,attrs:{token:s,classes:{matched:t.statusMap.has(s.href),mismatched:s.is("NOTEHEAD")&&!t.statusMap.has(s.href),tied:s.tied,attached:Number.isFinite(s.stemX),highlight:t.highlightSymbol&&s.is(t.highlightSymbol)},showTitle:t.showMark,scale:t.enabledFont?s.scale2:null},on:{click:function(e){return t.$emit("click-token",s,e)}}})})),1)})),t.showMark?e("g",{staticClass:"mark"},[t._t("staff",null,{staff:a,system:o,page:s})],2):t._e(),e("g",{staticClass:"markings"},t._l(a.markings,(function(s){return e("g",{key:s.index,class:s.cls,attrs:{transform:`translate(${s.x}, ${s.y+a.yRoundOffset})`}},[e("text",[t._v(t._s(s.text))]),s.alterText?e("text",{staticClass:"alter",attrs:{x:"-0.2",y:"0"}},[t._v(t._s(s.alterText))]):t._e()])})),0)],2)}))],2)}))],2),t.bakingMode?e("g",{staticClass:"bake"},t._l(s.systems,(function(s,o){return e("g",{key:o,staticClass:"system",attrs:{transform:`translate(${s.x}, ${s.y})`}},[t.showCursor&&t.cursorPosition&&t.cursorPosition.system===s.index?e("rect",{staticClass:"cursor",attrs:{x:t.cursorPosition.x,y:s.top-.5,width:"1",height:s.bottom-s.top+1}}):t._e(),t._l(s.staves,(function(s,o){return e("g",{key:o,staticClass:"staff",attrs:{transform:`translate(${s.x}, ${s.y})`}},[t._l(s.measures,(function(s,o){return e("g",{key:o,staticClass:"measure"},t._l(s.matchedTokens,(function(s,o){return e("g",{key:o,staticClass:"token matched",class:{tied:s.tied},attrs:{transform:`translate(${s.x}, ${s.y})`+(s.scale&&1!==s.scale?` scale(${s.scale})`:""),"data-track":s.track,"data-index":s.index}},[e("text",{attrs:{"data-href":s.href}},[t._v(t._s(s.fontUnicode))])])})),0)})),e("g",{staticClass:"markings"},t._l(s.markings,(function(o){return e("g",{key:o.index,class:o.cls,attrs:{transform:`translate(${o.x}, ${o.y+s.yRoundOffset})`}},[e("text",[t._v(t._s(o.text))]),o.alterText?e("text",{staticClass:"alter",attrs:{x:"-0.2",y:"0"}},[t._v(t._s(o.alterText))]):t._e()])})),0)],2)}))],2)})),0):t._e()])])})),0)},a=[],i=s("2b0e"),n=s("4b63"),r=s("6a98"),c=s("5027");class l{constructor(t=!1){t&&this.lock()}get locked(){return!!this.resolve}lock(){return console.assert(!this.locked,"[SingleLock] duplicated locking, last locking has't been released yet."),this.promise=new Promise(t=>this.resolve=t),this.promise}release(t){this.resolve&&(this.resolve(t),this.resolve=null)}wait(){return this.promise}}class d{constructor(t=Date){this.tasks={},this.handlers={},this.timer=t}clear(){Object.values(this.handlers).forEach(t=>clearTimeout(t)),this.tasks={},this.handlers={}}getTask(t){const e=Math.max(t-this.timer.now(),0);return this.tasks[t]||(this.tasks[t]=new Promise(s=>{this.handlers[t]=setTimeout(s,e)}).then(()=>{delete this.tasks[t],delete this.handlers[t]})),this.tasks[t]}appendTask(t,e){this.tasks[t]=this.getTask(t).then(e)}}var h=function(){var t=this,e=t._self._c;return e("g",{staticClass:"token",class:t.classes,attrs:{transform:`translate(${t.token.x}, ${t.token.y})`+(t.scale?` scale(${t.scale.x}, ${t.scale.y})`:""),"data-index":t.token.index,"data-href":t.token.href,"data-track":t.token.track},on:{click:function(e){return t.$emit("click",e)}}},[e("use",{class:t.token.classes,attrs:{"data-href":t.token.href,"xlink:href":"#sign-"+t.token.hash}}),t.showTitle&&t.token.href?e("title",[t._v(t._s(t.token.href))]):t._e()])},f=[],u={name:"sheet-token",props:{token:Object,classes:Object,showTitle:Boolean,scale:Object}},g=u,A=(s("b30c"),s("2877")),m=Object(A["a"])(g,h,f,!1,null,"5fc078a1",null),k=m.exports;class p{add(){}remove(){}}class y{constructor(t){this.elems=t}add(t){this.elems.forEach(e=>e.classList.add(t))}remove(t){this.elems.forEach(e=>e.classList.remove(t))}get value(){return this.elems[0]&&this.elems[0].value}set value(t){this.elems.forEach(e=>e.value=t)}}const v=(t,e=document)=>{const s=e.querySelectorAll(`.token *[data-href='${t}']`);return 0===s.length?new p:1===s.length?s[0].classList:new y(s)},w=Object({NODE_ENV:"production",BASE_URL:""}).VUE_APP_DEFAULT_WATERMARK;var x={name:"sheet-live",components:{SheetToken:k},props:{doc:Object,midiNotation:Object,pitchContextGroup:Array,showMark:Boolean,showCursor:{type:Boolean,default:!0},noteHighlight:{type:Boolean,default:!0},bakingMode:{type:Boolean,default:!1},backgroundImages:Array,enablePointer:{type:Boolean,default:!1},showPagesProgressively:{type:Boolean,default:!1},partialVisible:{type:Boolean,default:!0},scheduler:Object,watermark:{type:String,default:w},enabledFont:Boolean,highlightSymbol:String},data(){return{midiPlayer:null,statusMap:new Map,shownPages:[],watermarkSize:{width:256,height:256}}},computed:{progressTicks(){return this.midiPlayer&&this.midiPlayer.progressTicks},cursorPosition(){return this.midiPlayer&&this.scheduler?this.scheduler.lookupPosition(this.progressTicks):null},cursorPageIndex(){if(!this.cursorPosition||!this.doc)return null;const t=this.doc.systems[this.cursorPosition.system];return console.assert(t,"invalid cursor system index:",this.cursorPosition),t?t.pageIndex:null},cursorSystemIndex(){return this.cursorPosition&&this.doc?this.cursorPosition.system:null},cursorRowIndex(){return this.cursorSystemIndex},svgScale(){const t=this.doc&&this.doc.pages[0];return t?this.doc.pageSize.width/t.viewBox.width:1},isPlaying(){return this.midiPlayer&&this.midiPlayer.isPlaying}},created(){if(this.pageLoadingLock=new l,this.schedulePool=new d(performance),this.preparePlayer(),this.showPages(),this.watermark){const t=new Image;t.src=this.watermark,t.onload=()=>{this.watermarkSize.width=t.naturalWidth,this.watermarkSize.height=t.naturalHeight}}},methods:{onPlayerMidi(t,e){if(this.$emit("midi",t,e),this.noteHighlight&&t.ids){let s=null;const o=t.ids;switch(t.subtype){case"noteOn":s=()=>o.forEach(t=>{const e=this.statusMap.get(t);e&&e.add("on")});break;case"noteOff":s=()=>o.forEach(t=>{const e=this.statusMap.get(t);e&&e.remove("on")});break}s&&this.schedulePool.appendTask(e,s)}},setNoteStatus(t,e,s){if(this.midiNotation){const o=this.midiNotation.notes[t];o?o.ids&&o.ids.forEach(t=>{const o=this.statusMap.get(t);o&&(s?o.add(e):o.remove(e))}):console.warn("invalid note index:",t,this.midiNotation.notes.length)}},clearNoteStatus(){for(const t of this.statusMap.values())t.value=""},updateTokenStatus(){if(this.midiNotation&&this.noteHighlight)for(const t of this.midiNotation.notes){const e=this.midiPlayer.isPlaying&&this.midiPlayer.progressTime>=t.start&&this.midiPlayer.progressTime<t.start+t.duration;t.ids&&t.ids.forEach(t=>{const s=this.statusMap.get(t);s&&(e?s.add("on"):s.remove("on"))})}},async preparePlayer(){if(this.statusMap.clear(),this.midiPlayer&&(this.midiPlayer.dispose(),this.midiPlayer=null),this.midiNotation&&(this.updateMidiPlayer(),await this.$nextTick(),await this.pageLoadingLock.wait(),this.updateStatusMap(),!this.scheduler)){const t=this.doc&&this.doc.getTokenMap();if(t){for(const s of t.values())i["a"].set(s,"on",s.on||!1);const e=r["a"].createFromNotation(this.midiNotation,t);this.$emit("update:scheduler",e)}}},updateMidiPlayer(){this.midiPlayer&&this.midiPlayer.dispose(),this.midiPlayer=new n["MidiPlayer"](this.midiNotation,{cacheSpan:400,onMidi:(t,e)=>this.onPlayerMidi(t,e),onTurnCursor:()=>this.updateTokenStatus()})},updateStatusMap(){this.midiNotation&&this.midiNotation.notes.forEach(t=>t.ids&&t.ids.forEach(t=>{this.statusMap.get(t)||this.statusMap.set(t,v(t,this.$el))}))},updateStatusMapInPage(t){const e=t.querySelectorAll(".token *[data-href]");e.forEach(e=>{const s=e.dataset.href;this.statusMap.set(s,v(s,t))})},addMarkingByTick(t,e,s,{id:o,cls:a,text:i="",xoffset:n=0}={}){if(!this.pitchContextGroup)return void console.warn("[addMarkingByTick]\tpitchContextGroup is required.");const r=this.pitchContextGroup[s];if(!r)return void console.warn("[addMarkingByTick]\tinvalid staffIndex:",s,this.pitchContextGroup.length);const c=this.scheduler.lookupPosition(t);if(!c)return void console.warn("[addMarkingByTick]\tinvalid tick:",t);const l=r.lookup(t);if(!l)return console.warn("no context at tick:",t,r),null;const{y:d,alter:h}=l.pitchToY(e);return this.doc.addMarking(c.system,s,{x:c.x+n,y:d,text:i,alter:h,id:o,cls:a})},addMarkingByNote(t,e,{id:s=null,cls:o,text:a=""}={}){console.assert(this.midiNotation,"[addMarkingByNote]\tmidiNotation is null.");const i=this.midiNotation.notes[t];if(i){if(!s){if(!i.ids)return null;s=i.ids[0]}return this.addMarkingByTick(i.startTick,e,i.staffTrack,{id:s,cls:o,text:a,xoffset:1.2})}console.warn("[addMarkingByNote]\tinvalid noteIndex:",t,this.midiNotation.notes.length)},removeMarking(t){this.doc.removeMarking(t)},clearMarkings(){this.doc.clearMarkings()},async showPages(){if(this.shownPages=[],this.doc)if(this.showPagesProgressively){await this.pageLoadingLock.wait(),this.pageLoadingLock.lock();for(let t=0;t<this.doc.pages.length;++t)this.shownPages.push(this.doc.pages[t]),await this.$nextTick(),await Object(c["a"])();this.pageLoadingLock.release()}else this.shownPages=this.doc.pages},onDocChanged(){this.clearNoteStatus(),this.clearMarkings(),this.showPages()},eventToSystemPosition(t,e){return{x:e.offsetX/this.svgScale-t.x,y:e.offsetY/this.svgScale-t.y}},eventToPointer(t,e){const s=this.eventToSystemPosition(t,e),o=t.index,a=this.doc.lookupMeasureIndex(o,s.x),i=this.scheduler&&this.scheduler.lookupTick({system:o,x:s.x});return{systemIndex:o,measureIndex:a,tick:i,...s}},onMousemovePad(t,e){this.$emit("pointerUpdate",this.eventToPointer(t,e))},onMouseleavePad(){this.$emit("pointerUpdate",null)},onClickPad(t,e){this.$emit("pointerClick",this.eventToPointer(t,e),e)},updatePageVisibility(){this.$refs.pages?this.$refs.pages.forEach((t,e)=>{const s=t.getBoundingClientRect(),o=this.shownPages[e],a=s.top>window.innerHeight||s.bottom<0||s.left>window.innerWidth||s.right<0;!!o.hidden!==a&&i["a"].set(o,"hidden",a)}):console.log("[updatePageVisibility] $refs.pages is null:",this.$refs.pages)},onPageChanged(t){t.target&&"g"===t.target.nodeName&&this.updateStatusMapInPage(t.target)}},watch:{midiNotation:"preparePlayer",midiPlayer(t){this.$emit("update:midiPlayer",t)},async bakingMode(){await this.$nextTick(),await this.pageLoadingLock.wait(),this.updateStatusMap(),this.updateTokenStatus()},doc:"onDocChanged",cursorPageIndex(t){this.$emit("cursorPageShift",t)},cursorSystemIndex(t){this.$emit("cursorSystemShift",t)},isPlaying(t){t||this.schedulePool.clear()}}},b=x,B=(s("4a93"),s("6c11"),s("50f4"),Object(A["a"])(b,o,a,!1,null,"dc74d054",null));e["a"]=B.exports},b047:function(t,e,s){var o=s("1a8c"),a=s("408c"),i=s("b4b0"),n="Expected a function",r=Math.max,c=Math.min;function l(t,e,s){var l,d,h,f,u,g,A=0,m=!1,k=!1,p=!0;if("function"!=typeof t)throw new TypeError(n);function y(e){var s=l,o=d;return l=d=void 0,A=e,f=t.apply(o,s),f}function v(t){return A=t,u=setTimeout(b,e),m?y(t):f}function w(t){var s=t-g,o=t-A,a=e-s;return k?c(a,h-o):a}function x(t){var s=t-g,o=t-A;return void 0===g||s>=e||s<0||k&&o>=h}function b(){var t=a();if(x(t))return B(t);u=setTimeout(b,w(t))}function B(t){return u=void 0,p&&l?y(t):(l=d=void 0,f)}function C(){void 0!==u&&clearTimeout(u),A=0,l=g=d=u=void 0}function M(){return void 0===u?f:B(a())}function P(){var t=a(),s=x(t);if(l=arguments,d=this,g=t,s){if(void 0===u)return v(g);if(k)return clearTimeout(u),u=setTimeout(b,e),y(g)}return void 0===u&&(u=setTimeout(b,e)),f}return e=i(e)||0,o(s)&&(m=!!s.leading,k="maxWait"in s,h=k?r(i(s.maxWait)||0,e):h,p="trailing"in s?!!s.trailing:p),P.cancel=C,P.flush=M,P}t.exports=l},b1a2:function(t,e,s){var o=s("24fb");e=o(!1),e.push([t.i,".sign line[data-v-7dcb4590],.sign polygon[data-v-7dcb4590]{stroke:inherit}.sign path[data-v-7dcb4590],.sign polygon[data-v-7dcb4590],.sign rect[data-v-7dcb4590]{fill:inherit}.sign path[data-v-7dcb4590]{stroke:inherit}.sign .font-char[data-v-7dcb4590]{font-family:var(--music-font-family);font-size:var(--music-font-size)}",""]),t.exports=e},b1f3:function(t,e,s){var o=s("24fb"),a=s("3ed0");e=o(!1),e.i(a),e.push([t.i,".sheet .bake .token text{fill:var(--lotus-token-default-color)}.sheet .bake .token text.on{fill:var(--lotus-token-on-color);stroke-width:.1;stroke:var(--lotus-token-on-color)}",""]),t.exports=e},b30c:function(t,e,s){"use strict";s("2462")},b4b0:function(t,e,s){var o=s("8d74"),a=s("1a8c"),i=s("ffd6"),n=NaN,r=/^[-+]0x[0-9a-f]+$/i,c=/^0b[01]+$/i,l=/^0o[0-7]+$/i,d=parseInt;function h(t){if("number"==typeof t)return t;if(i(t))return n;if(a(t)){var e="function"==typeof t.valueOf?t.valueOf():t;t=a(e)?e+"":e}if("string"!=typeof t)return 0===t?t:+t;t=o(t);var s=c.test(t);return s||l.test(t)?d(t.slice(2),s?2:8):r.test(t)?n:+t}t.exports=h},ddcc:function(t,e,s){"use strict";var o=function(){var t=this,e=t._self._c;return e("button",{class:`check-button ${t.classes} ${t.value?"on":"off"}`,domProps:{innerHTML:t._s(t.content)},on:{click:t.onClick}})},a=[],i={name:"check-button",props:{value:Boolean,classes:{type:String,default:""},content:String},methods:{onClick(){this.$emit("input",!this.value)}}},n=i,r=(s("8a81"),s("2877")),c=Object(r["a"])(n,o,a,!1,null,"58f51ec2",null);e["a"]=c.exports},e179:function(t,e,s){var o=s("24fb"),a=s("3ed0");e=o(!1),e.i(a),e.push([t.i,".sheet .mark[data-v-dc74d054]{opacity:0}.sheet .mark .locator text[data-v-dc74d054]{font-size:2px;text-anchor:start;pointer-events:none}.sheet .mark rect[data-v-dc74d054]{fill:transparent}.sheet .cursor[data-v-dc74d054],.sheet .wm[data-v-dc74d054]{pointer-events:none}.sheet .bake[data-v-dc74d054]{font-family:var(--music-font-family)}.sheet .bake .token text[data-v-dc74d054]{pointer-events:none}.sheet .bake .token text[data-v-dc74d054],.sheet .markings text[data-v-dc74d054]{-webkit-user-select:none;-moz-user-select:none;user-select:none;font-size:var(--music-font-size)}.sheet .markings text[data-v-dc74d054]{font-family:var(--music-font-family)}.sheet .markings .alter[data-v-dc74d054]{text-anchor:end}",""]),t.exports=e},eaac:function(t,e,s){"use strict";s("5f3d")},f7ce:function(t,e,s){"use strict";var o=function(){var t=this,e=t._self._c;return e("svg",{staticClass:"sheet-signs",attrs:{xmlns:"http://www.w3.org/2000/svg"}},[e("defs",t._l(t.signs,(function(s){return e("g",{key:s.id,staticClass:"sign",attrs:{id:"sign-"+s.id,transform:s.def.scale&&!s.glyph&&`scale(${s.def.scale.x}, ${s.def.scale.y})`}},[s.glyph?e("text",{staticClass:"font-char",attrs:{"text-anchor":"start"},domProps:{innerHTML:t._s(s.glyph)}}):t._e(),"path"!==s.def.type||s.glyph?t._e():e("path",{attrs:{d:s.def.d,"stroke-width":s.def["stroke-width"]}}),"rect"===s.def.type?e("rect",{attrs:{x:s.def.width>=0?0:s.def.width,y:s.def.height>=0?0:s.def.height,width:Math.abs(s.def.width),height:Math.abs(s.def.height)}}):t._e(),"line"===s.def.type?e("line",{attrs:{x1:"0",y1:"0",x2:s.def.width,y2:s.def.height,"stroke-width":s.def["stroke-width"],"stroke-dasharray":s.def["stroke-dasharray"]}}):t._e(),"polygon"===s.def.type?e("polygon",{attrs:{points:s.def.points,"stroke-width":s.def["stroke-width"]}}):t._e(),"text"===s.def.type?e("text",{attrs:{"font-size":s.def["font-size"],"font-weight":s.def["font-weight"],"font-style":s.def["font-style"],"text-anchor":s.def["text-anchor"],fill:s.def.color}},[e("tspan",[t._v(t._s(s.def.text))])]):t._e()])})),0)])},a=[],i=s("32c1"),n={name:"sheet-signs",props:{hashTable:Object,enabledFont:Boolean},computed:{signs(){return this.hashTable?Object.entries(this.hashTable).map(([t,e])=>({id:t,def:e,glyph:this.enabledFont?i["glyph"].glyphHash[t]&&i["glyph"].GlyphUnicode[i["glyph"].glyphHash[t]]:null})):[]}}},r=n,c=(s("eaac"),s("2877")),l=Object(c["a"])(r,o,a,!1,null,"7dcb4590",null);e["a"]=l.exports},f7f3:function(t,e,s){var o=s("e179");o.__esModule&&(o=o.default),"string"===typeof o&&(o=[[t.i,o,""]]),o.locals&&(t.exports=o.locals);var a=s("499e").default;a("7daddbf7",o,!0,{sourceMap:!1,shadowMode:!1})},ffd6:function(t,e,s){var o=s("3729"),a=s("1310"),i="[object Symbol]";function n(t){return"symbol"==typeof t||a(t)&&o(t)==i}t.exports=n}}]);
+//# sourceMappingURL=chunk-40965e1a.74707226.js.map

dist/js/chunk-a06ef50c.1caef24f.js

@@ -0,0 +1,2 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-a06ef50c"],{1773:function(e,t,n){"use strict";n.d(t,"a",(function(){return s})),n.d(t,"e",(function(){return l})),n.d(t,"f",(function(){return c})),n.d(t,"c",(function(){return i})),n.d(t,"d",(function(){return u})),n.d(t,"b",(function(){return f}));var r=n("27e2"),o=n("43fb"),a=n("6977");function s(e,t){let n=t;for(;;){if(!Array.isArray(n))break;{if(0===n.length)break;n=Object(o["i"])(e,n);const t=Object(r["d"])(n[0]);if(!t)break;{const r=Object(o["h"])(e,t,n);if(!r)break;n=r.fn(r.actualArgs)}}Object(a["d"])(e)}return n}function l(e,t){if(!Array.isArray(t)||!Object(r["d"])(t[0],e.config.reservedNames.quote))throw new Error("[SX] stripQuote: token is not quoted.");return t[1]}function c(e,t){return Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.quote)?t[1]:t}function i(e){return function(){return Object(o["e"])(e)}}function u(e,t){return Object(a["b"])("(compiler)resolveValueSymbol_dynamic",t),function(){return Object(o["j"])(e,{symbol:t})}}function f(e){return function(t){return Object(a["b"])(e,t)}}},"27e2":function(e,t,n){"use strict";function r(e,t){return[{symbol:e.config.reservedNames.quote},t]}function o(e,t){if(Array.isArray(t)&&0<t.length){const n=f(t);if(n&&n.symbol===e.config.reservedNames.quote)return!0}return!1}function a(e,t){return[{symbol:e.config.reservedNames.backquote},t]}function s(e,t){if(Array.isArray(t)&&0<t.length){const n=f(t);if(n&&n.symbol===e.config.reservedNames.backquote)return!0}return!1}function l(e,t){return[{symbol:e.config.reservedNames.unquote},t]}function c(e,t){if(Array.isArray(t)&&0<t.length){const n=f(t);if(n&&n.symbol===e.config.reservedNames.unquote)return!0}return!1}function i(e,t){return[{symbol:e.config.reservedNames.spread},t]}function u(e,t){return[{symbol:e.config.reservedNames.splice},t]}function f(e,t){return e&&"object"===typeof e&&Object.prototype.hasOwnProperty.call(e,"symbol")?void 0!==t?e.symbol===t?e:null:e:null}n.d(t,"f",(function(){return r})),n.d(t,"c",(function(){return o})),n.d(t,"a",(function(){return a})),n.d(t,"b",(function(){return s})),n.d(t,"i",(function(){return l})),n.d(t,"e",(function(){return c})),n.d(t,"h",(function(){return i})),n.d(t,"g",(function(){return u})),n.d(t,"d",(function(){return f}))},"43fb":function(e,t,n){"use strict";n.d(t,"l",(function(){return a})),n.d(t,"i",(function(){return l})),n.d(t,"h",(function(){return c})),n.d(t,"k",(function(){return u})),n.d(t,"j",(function(){return f})),n.d(t,"a",(function(){return m})),n.d(t,"c",(function(){return b})),n.d(t,"f",(function(){return $})),n.d(t,"m",(function(){return p})),n.d(t,"e",(function(){return _})),n.d(t,"d",(function(){return d})),n.d(t,"g",(function(){return g})),n.d(t,"b",(function(){return j}));var r=n("27e2"),o=n("6977");function a(e){switch(typeof e){case"object":case"symbol":case"function":return NaN;default:return Number(e)}}function s(e,t){for(let n=0;n<t.length;n++){const o=Array.isArray(t[n])&&Object(r["d"])(t[n][0],e.config.reservedNames.unquote);o&&(t=t.slice(0,n).concat([j(e,t[n][1])],t.slice(n+1))),Array.isArray(t[n])&&(t=t.slice(0),t[n]=s(e,t[n]))}return l(e,t)}function l(e,t){if(e.config.enableSplice)for(let n=t.length-1;n>=0;n--){const o=Array.isArray(t[n])&&Object(r["d"])(t[n][0],e.config.reservedNames.splice);o&&(t=t.slice(0,n).concat(t[n][1],t.slice(n+1)))}return t}function c(e,t,n){const r=e.macroMap.get(t.symbol);let o=null;if(r){let a=r;const s=n.slice(1);while(a){if(!a.formalArgs)return{fn:a.fn(e,t.symbol),actualArgs:n};{const r=y(e,t.symbol,a.formalArgs,Boolean(a.lastIsSpread),s);if(!r.error)return{fn:a.fn(e,t.symbol,r.formalArgs),actualArgs:n.slice(0,1).concat(r.actualArgs)};o=r.error,a=a.next}}if(o)throw new Error(o)}return!1}function i(e,t){if("function"===typeof t)return t;const n=e.funcMap.get(t.symbol);if(n)return n.fn(e,t.symbol);{const n=f(e,t);if("function"===typeof n)return n;if(e.config.funcSymbolResolverFallback)return e.config.funcSymbolResolverFallback(e,t.symbol);if(e.config.raiseOnUnresolvedSymbol)throw new Error(`[SX] resolveFunctionSymbol: Unresolved symbol: ${t.symbol}.`);return t.symbol}}function u(e,t,n){for(let o=e.scopes.length-1;o>0;o--){const n=e.scopes[o];if(n&&Object.prototype.hasOwnProperty.call(n.scope,t.symbol))return n.scope;if(n.capturedScopes&&Object.prototype.hasOwnProperty.call(n.capturedScopes,t.symbol))return n.capturedScopes[t.symbol];if(!n.isBlockLocal)break}const r=d(e);return Object.prototype.hasOwnProperty.call(r.scope,t.symbol)?r.scope:n?null:_(e).scope}function f(e,t){const n=u(e,t,!0);if(n)return n[t.symbol];const r=e.symbolMap.get(t.symbol);if(r)return r.fn(e,t.symbol);if(e.config.valueSymbolResolverFallback)return e.config.valueSymbolResolverFallback(e,t.symbol);if(e.config.raiseOnUnresolvedSymbol)throw new Error(`[SX] resolveValueSymbol: Unresolved symbol: ${t.symbol}.`);return t.symbol}function m(e,t){const n={};for(const r of t){const t=u(e,r,!0);if(null===t)throw new Error("[SX] collectCapturedVariables: Unresolved symbols "+r);Object(o["c"])("collectCapturedVariables",n,r.symbol),n[r.symbol]=t}return n}function b(e){const t=[];for(let n=e.scopes.length-1;n>0;n--){const r=e.scopes[n];if(r.capturedScopes&&t.unshift(r.capturedScopes),!r.isBlockLocal)break}return t.length>0?Object.assign({},...t):void 0}function $(e,t,n,r){e.scopes.push({isBlockLocal:n,scope:t,capturedScopes:r})}function p(e){if(e.scopes.length<2)throw new Error("[SX] uninstallScope: Unable to pop stack.");return e.scopes.pop()}function _(e){return e.scopes[e.scopes.length-1]}function d(e){return e.scopes[0]}function y(e,t,n,o,a){if(n=n.slice(0),a=a.slice(0),a.length+(o?1:0)<n.length)return{error:`[SX] macro call (${t}): Actual args too short: actual ${a.length} / formal ${n.length}.`};for(let s=n.length-(o?2:1);s>=0;s--){let e=n[s].symbol;if(e.startsWith("!")){if(n[s].symbol=n[s].symbol.slice(1),e=n[s].symbol,!Object(r["d"])(a[s]))return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not symbol.`}}else if(e.startsWith("<")&&e.endsWith(">")){if(n[s].symbol=n[s].symbol.slice(1,-1),e=n[s].symbol,!Object(r["d"])(a[s],e))return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not expected symbol.`};n=n.slice(0,s).concat(n.slice(s+1)),a=a.slice(0,s).concat(a.slice(s+1))}else{const o=e.lastIndexOf(":");if(0<o){const l=e.slice(o+1);switch(l){case"number":if("number"!==typeof a[s])return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not number.`};break;case"string":if("string"!==typeof a[s])return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not string.`};break;case"function":if(!Array.isArray(a[s])||!Object(r["d"])(a[s][0]))return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not function.`};break;case"list":if(!Array.isArray(a[s]))return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not list.`};break;case"symbol":if(!Object(r["d"])(a[s]))return{error:`[SX] macro call (${t}): Actual arg(${s}: ${e}) is not symbol.`};break;case"any":break;default:return{error:`[SX] macro call (${t}): Formal arg(${s}: ${e}) is unknown type ${l}.`}}n[s].symbol=n[s].symbol.slice(0,o)}}}return{formalArgs:n,actualArgs:a}}function g(e,t,n){if(Array.isArray(n[n.length-1])){const r=n.slice(0,n.length-1),o=n[n.length-1];if(o&&"object"===typeof o[0]&&o[0].symbol===e.config.reservedNames.if&&Array.isArray(o[3])&&"object"===typeof o[3][0]&&o[3][0].symbol===e.config.reservedNames.self){const n=`$__tempvar__$$ec${e.evalCount++}$$_`,a=t.map((e,t)=>({symbol:`${n}_$i${t}_${e.symbol}`}));return[[{symbol:e.config.reservedNames.until},o[1],[{symbol:e.config.reservedNames.let},[...a],...r,...o[3].slice(1).map((t,n)=>[{symbol:e.config.reservedNames.set},a[n],t]),...a.map((n,r)=>[{symbol:e.config.reservedNames.set},t[r],n])]],...r,o[2]]}}return n}function j(e,t){if(Object(o["d"])(e),null===t||void 0===t)return t;let n=t;for(;;){if(!Array.isArray(n))break;{if(0===n.length)return n;n=l(e,n);const t=Object(r["d"])(n[0]);if(!t)break;{const r=c(e,t,n);if(!r)break;n=r.fn(r.actualArgs)}}Object(o["d"])(e)}if(Array.isArray(n)){if(n=n.slice(0),0<n.length){const t=Object(r["d"])(n[0]);if(t){if(t.symbol===e.config.reservedNames.quote)return n.slice(1,2)[0];if(t.symbol===e.config.reservedNames.backquote)return n=n.slice(1,2)[0],Array.isArray(n)&&(n=s(e,n)),n;if(t.symbol===e.config.reservedNames.eval)return j(e,j(e,n.slice(1,2)[0]))}const o=[];for(let s=1;s<n.length;s++){const t=Array.isArray(n[s])&&Object(r["d"])(n[s][0],e.config.reservedNames.spread);if(t){o.push(s);const t=j(e,n[s][1]);n[s]=Array.isArray(t)?t:[t]}else n[s]=j(e,n[s])}for(const e of o.reverse())n=n.slice(0,e).concat(n[e],n.slice(e+1));let a;if(a="function"===typeof n[0]?n[0]:t?i(e,t):j(e,n[0]),"function"!==typeof a)throw new Error(`[SX] evaluate: First item of list is not a function: ${JSON.stringify(n)}.`);n=a(...n.slice(1))}}else if(e.config.wrapExternalValue&&Object.prototype.hasOwnProperty.call(n,"value"))n=n.value;else if(Object.prototype.hasOwnProperty.call(n,"symbol"))n=f(e,n);else if(Object.prototype.hasOwnProperty.call(n,"car")){const t=j(e,n.car),r=j(e,n.cdr);if(Array.isArray(r)){const e=r.slice(0);e.unshift(t),n=e}else n={car:t,cdr:r}}else Object.prototype.hasOwnProperty.call(n,"dotted")?n=[j(e,n.dotted)]:Object.prototype.hasOwnProperty.call(n,"comment")&&(n=[]);return n}},6921:function(e,t,n){"use strict";n.d(t,"a",(function(){return r}));const r=Function("return this")()},6977:function(e,t,n){"use strict";n.d(t,"d",(function(){return a})),n.d(t,"a",(function(){return s})),n.d(t,"b",(function(){return i})),n.d(t,"c",(function(){return u}));var r=n("c541"),o=n("6921");function a(e){if(e.evalCount++,e.config.maxEvalCount&&e.config.maxEvalCount<e.evalCount)throw new r["b"]}function s(e,t,n,r){if(t.length<n)throw new Error(`[SX] ${e}: Invalid argument length: expected: ${n} / args: ${t.length}.`);if(r&&r<t.length)throw new Error(`[SX] ${e}: Invalid argument length: expected: ${r} / args: ${t.length}.`);return t}const l={}.constructor,c=Function;function i(e,t){if("__proto__"===t||"__defineGetter__"===t||"__defineSetter__"===t||"__lookupGetter__"===t||"__lookupSetter__"===t)throw new Error(`[SX] ${e}: Invalid var name ${t}.`);if("prototype"===t||"constructor"===t)throw new Error(`[SX] ${e}: Invalid var name ${t}.`);if(l.hasOwnProperty(t))throw new Error(`[SX] ${e}: Invalid var name ${t}.`);if("call"===t||"arguments"===t||"caller"===t)throw new Error(`[SX] ${e}: Invalid var name ${t}.`);return t}function u(e,t,n){if(t===o["a"]||"__proto__"===n||"__defineGetter__"===n||"__defineSetter__"===n||"__lookupGetter__"===n||"__lookupSetter__"===n)throw new Error(`[SX] ${e}: Invalid var name ${n}.`);if(("prototype"===n||"constructor"===n)&&(null===t||void 0===t||"function"===typeof t))throw new Error(`[SX] ${e}: Invalid var name ${n}.`);if((null===t||void 0===t||t===l)&&l.hasOwnProperty(n))throw new Error(`[SX] ${e}: Invalid var name ${n}.`);if(null===t||void 0===t||t===c){let t=c;while(t){if(t.hasOwnProperty(n))throw new Error(`[SX] ${e}: Invalid var name ${n}.`);t=t.__proto__}}if("function"===typeof t&&!t.hasOwnProperty(n))throw new Error(`[SX] ${e}: Invalid var name ${n}.`);return n}},7941:function(module,__webpack_exports__,__webpack_require__){"use strict";__webpack_require__.d(__webpack_exports__,"a",(function(){return compileLambda}));var _ast__WEBPACK_IMPORTED_MODULE_0__=__webpack_require__("27e2"),_evaluate__WEBPACK_IMPORTED_MODULE_1__=__webpack_require__("43fb"),_errors__WEBPACK_IMPORTED_MODULE_2__=__webpack_require__("6977"),_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__=__webpack_require__("1773"),_compile_ops__WEBPACK_IMPORTED_MODULE_4__=__webpack_require__("d8d6");function compileCore(e,t,n,r,o){function a(e){const t=new Map;for(const n of c.varNames.entries())t.set(n[0],n[1]);e(),c.varNames=t}function s(e){let t="";if(null===e)t+="(null)";else if(void 0===e)t+="(void 0)";else switch(typeof e){case"boolean":case"number":t+=`(${String(e)})`;break;case"object":if(Object(_ast__WEBPACK_IMPORTED_MODULE_0__["d"])(e)){const n=e;Object(_errors__WEBPACK_IMPORTED_MODULE_2__["c"])("(compiler)compileValue",c.varNames,n.symbol),c.varNames.has(n.symbol)?t+=`(${c.varNames.get(n.symbol)})`:(o[c.varsCount]=n.symbol,t+=`(_$_vars[${String(c.varsCount++)}])`);break}default:o[c.varsCount]=e,t+=`(_$_vars[${String(c.varsCount++)}])`;break}return t}function l(t,n){let r="";const a=t[n];if(Array.isArray(a))if(0<a.length){const t=Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["a"])(e,a);if(Array.isArray(t))if(0<t.length)if(Object(_ast__WEBPACK_IMPORTED_MODULE_0__["d"])(t[0])){const n=t[0],a=t.slice(1);Object(_errors__WEBPACK_IMPORTED_MODULE_2__["c"])("(compiler)compileToken",i,n.symbol),i.has(n.symbol)?r+=i.get(n.symbol)(t,a):n.symbol===e.config.reservedNames.spread?r+=`...(${a.map(t=>l([Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["f"])(e,t)],0)).join(",")})`:e.funcMap.has(n.symbol)?(o[c.varsCount]=e.funcMap.get(n.symbol).fn(e,""),r+=`((_$_vars[${String(c.varsCount++)}])(${a.map(t=>l([Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["f"])(e,t)],0)).join(",")}))`):c.varNames.has(n.symbol)?r+=`(${String(c.varNames.get(n.symbol))})(${a.map(t=>l([Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["f"])(e,t)],0)).join(",")})`:(o[c.varsCount]=Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["d"])(e,n.symbol),r+=`((_$_vars[${String(c.varsCount++)}])()(${a.map(t=>l([Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["f"])(e,t)],0)).join(",")}))`)}else switch(typeof t[0]){case"function":o[c.varsCount]=t[0],r+=`((_$_vars[${String(c.varsCount++)}])(${t.slice(1).map((t,n,r)=>l([Object(_compile_ops_helpers__WEBPACK_IMPORTED_MODULE_3__["f"])(e,t)],0)).join(",")}))`;break;default:throw new Error(`[SX] compileToken: First item of list is not a function: ${JSON.stringify(t[0])}.`)}else r+="([])";else r+=s(a)}else r+="([])";else r+=s(a);return r}const c={_$_vars:o,varsCount:1,varNames:new Map,varNamesCount:0,varDefs:"var x0;",ops:new Map,makeScope:a,compileToken:l};Object(_compile_ops__WEBPACK_IMPORTED_MODULE_4__["a"])(e,c);const i=c.ops;e.config.enableTailCallOptimization&&(r=Object(_evaluate__WEBPACK_IMPORTED_MODULE_1__["g"])(e,t,r)),c.varNames.set(e.config.reservedNames.thiz,"(this===(Function('return this')())?null:(this===void 0?null:this))");const u=Object(_evaluate__WEBPACK_IMPORTED_MODULE_1__["c"])(e);if(u)for(const b in u)Object.prototype.hasOwnProperty.call(u,b)&&(o[c.varsCount++]=b,o[c.varsCount]=u[b],c.varNames.set(b,`(_$_vars[${String(c.varsCount)}][_$_vars[${String(c.varsCount-1)}]])`),c.varsCount++);const f=""+t.map((e,r)=>(c.varNames.set(t[r].symbol,"a"+r),`${n&&r===t.length-1?"...":""}a${r}`)).join(","),m=`return(${r.map((e,t)=>l(r,t)).join(",")})`;return`(function(${f}){"strict";${c.varDefs}${m}})`}function evalCompiledLambda(_$_state,_$_vars,code){return _$_vars[0]=eval(code),_$_vars[0]}function compileLambda(e,t,n,r){const o=[];return evalCompiledLambda(e,o,compileCore(e,t,n,r,o))}},c541:function(e,t,n){"use strict";n.d(t,"a",(function(){return r})),n.d(t,"b",(function(){return o})),n.d(t,"c",(function(){return a}));class r extends Error{constructor(e){super(e)}}class o extends r{constructor(){super("[SX] evaluate: The maximum count of evaluations has been exceeded.")}}class a extends r{constructor(e){super(`[SX] ${e}: Unexpected termination of script.`)}}},d8d6:function(e,t,n){"use strict";n.d(t,"a",(function(){return s}));var r=n("27e2"),o=n("6977"),a=n("1773");function s(e,t){const{_$_vars:n,ops:s,makeScope:l,compileToken:c}=t;s.set(e.config.reservedNames.quote,(function(e,r){let o="";return n[t.varsCount]=e[1],o+=`(_$_vars[${String(t.varsCount++)}])`,o})),s.set(e.config.reservedNames.self,(function(t,n){let r="";return r+=`((_$_vars[0])(${n.map(t=>c([Object(a["f"])(e,t)],0)).join(",")}))`,r})),s.set("$__if",(function(t,n){let r="";return Object(o["a"])("compileToken:$__if",n,2,3),r+=`(${c(t,1)}?(${c([Object(a["e"])(e,t[2])],0)}):(${c([Object(a["e"])(e,t[3])],0)}))`,r})),s.set("$__if-null",(function(t,n){let r="";return Object(o["a"])("compileToken:$__if-null",n,2,2),r+=`((()=>{let _$_rv=${c(t,1)};return _$_rv?_$_rv:(${c([Object(a["e"])(e,t[2])],0)}});})())`,r})),s.set("$__cond",(function(t,n){let r="";Object(o["a"])("compileToken:$__cond",n,1),r+="(";for(let o=0;o<n.length;o+=2)r+=`${c([Object(a["e"])(e,n[o])],0)}?(${c([Object(a["e"])(e,n[o+1])],0)}):(`;r+="null";for(let e=0;e<n.length;e+=2)r+=")";return r+=")",r})),s.set("$__while",(function(t,n){let r="";return Object(o["a"])("compileToken:$__while",n,1),r+=`((()=>{let _$_rv=null;while(${c([Object(a["e"])(e,t[1])],0)}){_$_rv=${t.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}return _$_rv})())`,r})),s.set("$__do-while",(function(t,n){let r="";return Object(o["a"])("compileToken:$__do-until",n,1),r+=`((()=>{let _$_rv=null;do{_$_rv=${t.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}}while(${c([Object(a["e"])(e,t[1])],0)})return _$_rv)())`,r})),s.set("$__until",(function(t,n){let r="";return Object(o["a"])("compileToken:$__until",n,1),r+=`((()=>{let _$_rv=null;while(!${c([Object(a["e"])(e,t[1])],0)}){_$_rv=${t.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}return _$_rv})())`,r})),s.set("$__do-until",(function(t,n){let r="";return Object(o["a"])("compileToken:$__do-until",n,1),r+=`((()=>{let _$_rv=null;do{_$_rv=${t.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}}while(!${c([Object(a["e"])(e,t[1])],0)})return _$_rv)())`,r})),s.set("$__repeat",(function(n,s){let i="";if(Object(o["a"])("compileToken:$__repeat",s,2),!Object(r["d"])(s[0]))throw new Error("[SX] compileToken: $__repeat : args[0] is not symbol.");return l(()=>{const r="v"+t.varNamesCount++;t.varNames.set(s[0].symbol,r),i+=`(((_$_n)=>{let _$_rv=null;for(let ${r}=0;${r}<_$_n;${r}++){_$_rv=${n.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}return _$_rv})(${c(s,1)}))`}),i})),s.set("$__for",(function(n,s){let i="";if(Object(o["a"])("compileToken:$__for",s,2),!Object(r["d"])(s[0]))throw new Error("[SX] compileToken: $__for : args[0] is not symbol.");return l(()=>{const r="v"+t.varNamesCount++;t.varNames.set(s[0].symbol,r),i+=`(((_$_l)=>{let _$_rv=null;for(const ${r} of _$_l){_$_rv=${n.slice(2).map(t=>c([Object(a["e"])(e,t)],0)).join(",")}}return _$_rv})(${c(s,1)}))`}),i})),s.set("$__scope",(function(n,s){let i="";if(Object(o["a"])("compileToken:$__scope",s,2),!Array.isArray(n[3]))throw new Error("[SX] compileToken: $__scope : args[2] is not array.");return l(()=>{for(const s of Object(a["e"])(e,n[3])){let e="";if(Array.isArray(s)){if(s.length<1)throw new Error("[SX] compileToken: $__scope : args[0][?] is too short.");if(!Object(r["d"])(s[0]))throw new Error("[SX] compileToken: $__scope : args[0][?][0] is not symbol.");e=s[0].symbol,i+=`(${"v"+t.varNamesCount}=${c(s,1)})`}else{if(!Object(r["d"])(s))throw new Error("[SX] compileToken: $__scope : args[0][?] is not symbol.");e=s.symbol}t.varDefs+=`var v${t.varNamesCount}=void 0;`,t.varNames.set(e,"v"+t.varNamesCount++)}const o=""+n.slice(4).map(t=>c([Object(a["e"])(e,t)],0)).join(",");i+=n[2]?`[${o}]`:`(${o})`}),i})),s.set("$__try",(function(r,s){let i="";return Object(o["a"])("compileToken:$__try",s,1,2),i+=`((()=>{try{${c([Object(a["e"])(e,r[1])],0)}}catch(e${t.varNamesCount}){let e${t.varNamesCount+1}=(_$_vars[${String(t.varsCount)}])();`,n[t.varsCount++]=Object(a["c"])(e),l(()=>{t.varNames.set("$error","e"+t.varNamesCount++),t.varNames.set("$parent","e"+t.varNamesCount++),i+=c([Object(a["e"])(e,r[2])],0)+"}})())"}),i})),s.set(e.config.reservedNames.raise,(function(t,n){let r="";return r+=`((()=>{throw ${c([Object(a["f"])(e,t[1])],0)}})())`,r})),s.set("$boolean",(function(e,t){let n="";return Object(o["a"])("compileToken:$boolean",t,1,1),n+=`((x0=${c(t,0)}),(Array.isArray(x0)&&x0.length===0?false:boolean(x0)))`,n})),s.set("$__get",(function(s,l){let i="";Object(o["a"])("compileToken:$__get",l,1);const u=Object(a["e"])(e,s[1]),f=Object(r["d"])(u)?u.symbol:"string"===typeof u?u:null;if("string"!==typeof f)throw new Error(`[SX] compileToken: $__get : operand is not symbol: ${JSON.stringify(s[1])}.`);let m="";t.varNames.has(f)?m=t.varNames.get(f):(n[t.varsCount]=Object(a["d"])(e,f),m=`_$_vars[${String(t.varsCount++)}]`);const b=e=>(n[t.varsCount]=e,`_$_vars[${String(t.varsCount++)}]`);return i+=`((${m})${s.slice(2).map((e,t,n)=>`[${Object(r["d"])(n[t])?b(n[t].symbol):c(n,t)}]`).join("")})`,i})),s.set("$__let",(function(n,s){let l="";Object(o["a"])("compileToken:$__let",s,2,2);const i=Object(a["e"])(e,n[1]),u=Object(r["d"])(i)?i.symbol:"string"===typeof i?i:null;if("string"!==typeof u)throw new Error(`[SX] compileToken: $__let : operand is not rvalue: ${JSON.stringify(n[1])}.`);return t.varNames.has(u)||(t.varDefs+=`var v${t.varNamesCount}=void 0;`,t.varNames.set(u,"v"+t.varNamesCount++)),l+=`(${t.varNames.get(u)}=${c(n,2)})`,l})),s.set("$__set",(function(s,l){let i="";Object(o["a"])("compileToken:$__set",l,2);const u=Object(a["e"])(e,s[1]),f=Object(r["d"])(u)?u.symbol:"string"===typeof u?u:Array.isArray(u)?Object(r["d"])(u[0])?u[0].symbol:"string"===typeof u[0]?u[0]:null:null;if("string"!==typeof f)throw new Error(`[SX] compileToken: $__set : operand is not rvalue: ${JSON.stringify(s[1])}.`);let m="";t.varNames.has(f)?m=t.varNames.get(f):(n[t.varsCount]=Object(a["d"])(e,f),m=`_$_vars[${String(t.varsCount++)}]`);const b=e=>(n[t.varsCount]=Object(o["b"])("compileToken:$__set",e),`_$_vars[${String(t.varsCount++)}]`);let $=!1,p="";const _=e=>($||(n[t.varsCount]=Object(a["b"])("compileToken:$__set"),p=String(t.varsCount++),$=!0),`(_$_vars[${p}](${e}))`);return i+=`((${m})${(Array.isArray(u)?u.slice(1):[]).map((e,t,n)=>`[${Object(r["d"])(n[t])?b(n[t].symbol):_(c(n,t))}]`).join("")}=${c(s,2)})`,i})),s.set(e.config.reservedNames.not,(function(e,t){let n="";return Object(o["a"])("compileToken:$not",t,1,1),n+=`(!${c(t,0)})`,n})),s.set("$__and",(function(t,n){let r="";return Object(o["a"])("compileToken:$__and",n,1),r+=`(${n.map(t=>c([Object(a["e"])(e,t)],0)).join("&&")})`,r})),s.set("$__or",(function(t,n){let r="";return Object(o["a"])("compileToken:$__or",n,1),r+=`(${n.map(t=>c([Object(a["e"])(e,t)],0)).join("||")})`,r})),s.set("===",(function(e,t){let n="";return Object(o["a"])("compileToken:===",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("===")})`,n})),s.set("!==",(function(e,t){let n="";return Object(o["a"])("compileToken:!==",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("!==")})`,n})),s.set("==",(function(e,t){let n="";return Object(o["a"])("compileToken:==",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("==")})`,n})),s.set("!=",(function(e,t){let n="";return Object(o["a"])("compileToken:!=",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("!=")})`,n})),s.set("<",(function(e,t){let n="";return Object(o["a"])("compileToken:<",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("<")})`,n})),s.set("<=",(function(e,t){let n="";return Object(o["a"])("compileToken:<=",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("<=")})`,n})),s.set(">",(function(e,t){let n="";return Object(o["a"])("compileToken:>",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join(">")})`,n})),s.set(">=",(function(e,t){let n="";return Object(o["a"])("compileToken:<=",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join(">=")})`,n})),s.set("$concat",(function(t,n){let a="";Object(o["a"])("compileToken:$concat",n,1);let s="";if(Array.isArray(n[0])&&Object(r["d"])(n[0][0],e.config.reservedNames.spread)){const e=c(n[0],1);s=`(${e}[0]).concat((${e}.length>1?${e}[1]:(typeof ${e}[0]==='string'?'':[])),`}else s=c(n,0)+".concat(";return a+=`(${s}${n.slice(1).map((e,t,n)=>c(n,t)).join(",")}))`,a})),s.set("+",(function(t,n){let a="";Object(o["a"])("compileToken:+",n,1);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return _$_rv.reduce((x,y)=>x+y);})())`:`(${n.map((e,t,n)=>c(n,t)).join("+")})`,a})),s.set("-",(function(t,n){let a="";Object(o["a"])("compileToken:-",n,1);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return (_$_rv.length>1?(_$_rv.reduce((x,y)=>x-y)):(_$_rv.length>0?-_$_rv[0]:NaN));})())`:`(${t.length>2?n.map((e,t,n)=>c(n,t)).join("-"):`-(${String(c(t,1))})`})`,a})),s.set("*",(function(t,n){let a="";Object(o["a"])("compileToken:*",n,2);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return _$_rv.reduce((x,y)=>x*y);})())`:`(${n.map((e,t,n)=>c(n,t)).join("*")})`,a})),s.set("**",(function(t,n){let a="";Object(o["a"])("compileToken:**",n,2);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return _$_rv.reduce((x,y)=>x**y);})())`:`(${n.map((e,t,n)=>c(n,t)).join("**")})`,a})),s.set("/",(function(t,n){let a="";Object(o["a"])("compileToken:/",n,2);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return _$_rv.reduce((x,y)=>x/y);})())`:`(${n.map((e,t,n)=>c(n,t)).join("/")})`,a})),s.set("%",(function(t,n){let a="";Object(o["a"])("compileToken:%",n,2);let s=!1;return n.map((t,n,o)=>{Array.isArray(t)&&Object(r["d"])(t[0],e.config.reservedNames.spread)&&(s=!0)}),a+=s?`((()=>{let _$_rv=[];${n.map((e,t,n)=>`_$_rv.push(${c(n,t)})`).join(";")};return _$_rv.reduce((x,y)=>x%y);})())`:`(${n.map((e,t,n)=>c(n,t)).join("%")})`,a})),s.set("<<",(function(e,t){let n="";return Object(o["a"])("compileToken:<<",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("<<")})`,n})),s.set(">>",(function(e,t){let n="";return Object(o["a"])("compileToken:>>",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join(">>")})`,n})),s.set(">>>",(function(e,t){let n="";return Object(o["a"])("compileToken:>>>",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join(">>>")})`,n})),s.set("$bit-not",(function(e,t){let n="";return Object(o["a"])("compileToken:$bit-not",t,1,1),n+=`(~(${c(e,1)}))`,n})),s.set("$bit-and",(function(e,t){let n="";return Object(o["a"])("compileToken:$bit-and",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("&")})`,n})),s.set("$bit-or",(function(e,t){let n="";return Object(o["a"])("compileToken:$bit-or",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("|")})`,n})),s.set("$bit-xor",(function(e,t){let n="";return Object(o["a"])("compileToken:$bit-xor",t,2,2),n+=`(${t.map((e,t,n)=>c(n,t)).join("^")})`,n}))}},f587:function(e,t,n){"use strict";n.r(t),n.d(t,"FatalError",(function(){return r["a"]})),n.d(t,"MaxEvaluationCountError",(function(){return r["b"]})),n.d(t,"ScriptTerminationError",(function(){return r["c"]})),n.d(t,"quote",(function(){return o["f"]})),n.d(t,"isQuoted",(function(){return o["c"]})),n.d(t,"backquote",(function(){return o["a"]})),n.d(t,"isBackquoted",(function(){return o["b"]})),n.d(t,"wrapByUnquote",(function(){return o["i"]})),n.d(t,"isUnquoted",(function(){return o["e"]})),n.d(t,"spread",(function(){return o["h"]})),n.d(t,"splice",(function(){return o["g"]})),n.d(t,"isSymbol",(function(){return o["d"]})),n.d(t,"defaultReservedNames",(function(){return a})),n.d(t,"defaultConfig",(function(){return s})),n.d(t,"SExpression",(function(){return T})),n.d(t,"SExpressionAsync",(function(){return X})),n.d(t,"S",(function(){return x})),n.d(t,"L",(function(){return Qn})),n.d(t,"LS",(function(){return Zn})),n.d(t,"lisp",(function(){return er})),n.d(t,"L_async",(function(){return tr})),n.d(t,"LS_async",(function(){return nr})),n.d(t,"lisp_async",(function(){return rr})),n.d(t,"LM",(function(){return or})),n.d(t,"LM_async",(function(){return ar})),n.d(t,"LSX",(function(){return gr})),n.d(t,"LSX_async",(function(){return jr})),n.d(t,"runScriptTags",(function(){return Or})),n.d(t,"installCore",(function(){return St})),n.d(t,"installArithmetic",(function(){return Zt})),n.d(t,"installSequence",(function(){return Dn})),n.d(t,"installJsx",(function(){return yr})),n.d(t,"installConcurrent",(function(){return Yn})),n.d(t,"builtinOperators",(function(){return hr})),n.d(t,"builtinMacros",(function(){return vr})),n.d(t,"builtinSymbols",(function(){return wr}));var r=n("c541"),o=n("27e2");const a={eval:"$eval",quote:"$quote",backquote:"$backquote",unquote:"$unquote",spread:"$spread",splice:"$splice",car:"$car",cdr:"$cdr",cons:"$cons",atom:"$atom",eq:"$eq",list:"$list",let:"$clisp-let",lambda:"$lambda",self:"$self",defun:"$defun",thiz:"$this",if:"$if",cond:"$cond",while:"$while",doWhile:"$do-while",until:"$until",doUntil:"$do-until",get:"$get",defvar:"$clisp-defvar",setq:"$clisp-setq",set:"$set",call:"$call",not:"$not",and:"$and",or:"$or",isSymbol:"$is-symbol",gensym:"$gensym",raise:"$raise",catch:"$catch",Template:"Template"},s={raiseOnUnresolvedSymbol:!1,enableEvaluate:!0,enableHereDoc:!0,enableSpread:!0,enableSplice:!0,enableShorthands:!0,enableVerbatimStringLiteral:!0,enableTailCallOptimization:!0,enableRegExpMatchOperators:!0,enableCompilationOperators:!0,stripComments:!1,wrapExternalValue:!0,returnMultipleRoot:!1,maxEvalCount:0,reservedNames:a,symbols:[],macros:[],funcs:[]};function l(e){return"object"===typeof e&&Object.prototype.hasOwnProperty.call(e,"eof")}function c(e){return"string"===typeof e&&0===e.trim().length}function i(e){return"string"===typeof e&&/^[0-9\+\-]$/.test(e)}function u(e){return"string"===typeof e&&/^[0-9]$/.test(e)}function f(e){return"string"===typeof e&&!c(e)&&!i(e)}function m(e){return`line: ${e.line} / strings: ${e.index} / pos: ${e.pos} :${e.strings.length>e.index?e.strings[e.index].slice(e.pos,e.pos+20):""}`}function b(e,t,n){if(e.strings.length<=e.index)return{eof:!0};if(e.strings[e.index].length<=e.pos){if(!e.values||e.values.length<=e.index)return e.pos=0,e.index++,b(e);{const t={value:e.values[e.index]};return e.pos=0,e.index++,t}}if(t)for(const r of t){const t=e.strings[e.index].slice(e.pos,e.pos+r.length);if(t===r)return e.pos+=r.length,e.line+=t.split("\n").length-1,{eof:!1,eofSeq:r}}{let t=e.strings[e.index].slice(e.pos,e.pos+1);if(e.pos++,"\n"===t&&e.line++,!n&&"\\"===t){if(e.strings[e.index].length<=e.pos)throw new Error(`[SX] getChar: Invalid syntax at: ${m(e)}.`);switch(t=e.strings[e.index].slice(e.pos,e.pos+1),e.pos++,t){case"b":t="\b";break;case"t":t="\t";break;case"n":t="\n";break;case"v":t="\v";break;case"f":t="\f";break;case"r":t="\r";break;case"U":case"u":if("{"===e.strings[e.index].slice(e.pos,e.pos+1)){let n="";for(let t=0;t<6;t++){const r=e.strings[e.index].slice(e.pos+t,e.pos+1+t);if("}"===r){if(0===t)throw new Error(`[SX] getChar: Invalid syntax at: ${m(e)}.`);e.pos+=t;break}if(!/^[0-9A-Fa-f]{1}$/.test(n))throw new Error(`[SX] getChar: Invalid syntax at: ${m(e)}.`);n+=r}if("}"!==e.strings[e.index].slice(e.pos,e.pos+1))throw new Error(`[SX] getChar: Invalid syntax at: ${m(e)}.`);e.pos++,t=String.fromCodePoint(Number.parseInt(n,16))}else{const n=e.strings[e.index].slice(e.pos,e.pos+4);if(!/^[0-9A-Fa-f]{4}$/.test(n))throw new Error(`[SX] getChar: Invalid syntax at: ${m(e)}.`);e.pos+=4,t=String.fromCodePoint(Number.parseInt(n,16))}break}}return t}}function $(e,t,n,r){const o=e.index,a=e.pos,s=e.line,l=[];try{for(let o=0;o<t;o++)l.push(b(e,n,r))}finally{e.index=o,e.pos=a,e.line=s}return l}function p(e,t,n){const r=e.index,o=e.pos,a=e.line;let s;try{s=b(e,t,n)}finally{e.index=r,e.pos=o,e.line=a}return s}function _(e){let t=p(e);while(!l(t)&&c(t))b(e),t=p(e)}function d(e,t){let n="",r=p(e,t);while(!l(r)){if("string"!==typeof r)break;if(/^0[XxOoBb][0-9]*$/.test(n+r))b(e,t),n+=r;else{if(!/^[0-9\+\-\.EeInfinityNaN]+$/.test(n+r))break;b(e,t),n+=r}r=p(e,t)}if(!/^([\+\-]?\d*\.?\d+(?:[Ee][\+\-]?\d+)?)|(0[XxOoBb][0-9]+)|([\+\-]Infinity)|(NaN)$/.test(n))throw new Error(`[SX] parseNumber: Invalid syntax at: ${m(e)}.`);return Number(n)}function y(e,t){let n="",r=p(e,t);while(!l(r)){if("string"===typeof r){if(c(r))break;if("#"===r&&"|"===$(e,2,t)[1])break;if(!/^[^.;()"]+$/.test(n+r))break;b(e,t),n+=r}else{if("object"!==typeof r||!Object.prototype.hasOwnProperty.call(r,"value"))throw new Error(`[SX] parseSymbol: Invalid syntax at: ${m(e)}.`);b(e,t);r.value;n+=String(r)}r=p(e,t)}if(e.config.enableShorthands){let t=null;if(t=n.match(/^:((?:\:[^=:]+?)+?)=$/)){const n=t[1].slice(1).split(":"),r=[{symbol:e.config.reservedNames.splice},[{symbol:e.config.reservedNames.set},n]];return r}if(t=n.match(/^:((?:\:[^@:]+?)+?)@([^@:]+?)$/)){const n=t[1].slice(1).split(":"),r=[{symbol:e.config.reservedNames.splice},[{symbol:e.config.reservedNames.call},[{symbol:e.config.reservedNames.get},...n],{symbol:t[2]}]];return r}if(t=n.match(/^:((?:\:[^:]+?)+?)$/)){const n=t[1].slice(1).split(":"),r=[{symbol:e.config.reservedNames.get},...n];return r}}return{symbol:n}}function g(e,t,n,o,a,s){const c=n?[...t,n]:t,i=[],u=[];for(;;){let t="",f=p(e,c,a);while(!l(f)){if("string"===typeof f)b(e,c,a),t+=f;else{if("object"!==typeof f||!Object.prototype.hasOwnProperty.call(f,"value"))throw new Error(`[SX] parseStringOrComment: Invalid syntax at: ${m(e)}.`);b(e,c,a);f.value;t+=String(f)}f=p(e,c,a)}if(b(e,c,a),!0===f.eof&&!s)throw new r["c"]("parseStringOrComment");if(i.push(t),f.eofSeq!==n)break;u.push(S(e,o,[]))}return{strings:i,values:u}}function j(e,t){return g(e,['"'],null,")",t,!1).strings[0]}function O(e,t,n){const r=[t];n&&r.push(n);const o=g(e,['"""'],"%%%(",")",!1,!1);for(let a=0;a<o.strings.length;a++)r.push(o.strings[a]),a<o.values.length&&r.push(o.values[a]);return r}function h(e){return{comment:g(e,["\r","\n"],null,")",!1,!0).strings[0]}}function v(e){return{comment:g(e,["|#"],null,")",!1,!1).strings[0]}}function w(e){_(e);let t=p(e);while(!l(t)){switch(t){case")":throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`);case"(":return b(e),S(e,")",[]);case"'":case"`":case",":{b(e);const n=p(e);let r=!1;","===t&&"@"===n&&(b(e),r=!0),_(e);const a=("'"===t?o["f"]:"`"===t?o["a"]:o["i"])(e,w(e));return r?Object(o["g"])(e,a):a}case".":{b(e);const t=$(e,2);return e.config.enableSpread&&"."===t[0]&&"."===t[1]?(b(e),b(e),_(e),Object(o["h"])(e,w(e))):(_(e),{dotted:w(e)})}case";":return b(e),h(e);case"#":{const t=$(e,2);return"|"===t[1]?(b(e),b(e),v(e)):y(e)}case'"':{b(e);const t=$(e,4);if(e.config.enableHereDoc&&'"'===t[0]&&'"'===t[1]){let n=!0;l(t[2])||c(t[2])||(i(t[2])?"+"!==t[2]&&"-"!==t[2]||u(t[3])||(n=!1):f(t[2])&&(n=!1)),b(e),b(e);let r=null,o=null;if(n)r={symbol:e.config.reservedNames.Template};else{if(r=y(e,["@"]),null===r)throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`);if("number"===typeof r)throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`);const t=$(e,2);if("@"===t[0]){if("{"!==t[1])throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`);b(e),b(e);const n=S(e,"}",[{symbol:"@"}]);Array.isArray(n)&&(o=n)}}return O(e,r,o)}return j(e,!1)}case"@":if(e.config.enableVerbatimStringLiteral){const t=$(e,2);if('"'===t[1])return b(e),b(e),j(e,!0)}default:if("string"!==typeof t){if("object"===typeof t&&Object.prototype.hasOwnProperty.call(t,"value"))return b(e),e.config.wrapExternalValue?t:t.value;throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`)}if(c(t))break;if(i(t)){if("+"===t||"-"===t){const t=$(e,2);if(!u(t[1]))return y(e)}return d(e)}if(f(t))return y(e);throw new Error(`[SX] parseOneToken: Invalid syntax at: ${m(e)}.`)}_(e),t=p(e)}throw new r["c"]("parseOneToken")}function S(e,t,n){const o=n.slice(0);let a=!1;_(e);let s=p(e);while(!l(s)){switch(s){case t:return b(e),a?o[0]:o;default:{const t=w(e);if("object"===typeof t&&Object.prototype.hasOwnProperty.call(t,"dotted")){if(1!==o.length)throw new Error(`[SX] parseList: Invalid syntax at: ${m(e)}.`);a=!0,Array.isArray(t)?(t.unshift(o.pop()),o.push(t)):o.push({car:o.pop(),cdr:t.dotted})}else if("object"===typeof t&&Object.prototype.hasOwnProperty.call(t,"comment"))e.config.stripComments||o.push(t);else{if(a)throw new Error(`[SX] parseList: Invalid syntax at: ${m(e)}.`);o.push(t)}}break}_(e),s=p(e)}throw new r["c"]("parseList")}function A(e){const t=[];_(e);let n=p(e);while(!l(n)){switch(n){case"(":b(e),t.push(S(e,")",[]));break;case"'":case"`":for(b(e),_(e);;){const r=w(e);if("object"!==typeof r||!Object.prototype.hasOwnProperty.call(r,"comment")){t.push(("'"===n?o["f"]:o["a"])(e,r));break}e.config.stripComments||t.push(r)}break;case";":b(e),e.config.stripComments?h(e):t.push(h(e));break;case"#":{const n=$(e,2);"|"===n[1]?(b(e),b(e),e.config.stripComments?v(e):t.push(v(e))):(b(e),e.config.stripComments?h(e):t.push(h(e)))}break;case'"':{const n=$(e,3);if('"'===n[1]&&'"'===n[2]){t.push(w(e));break}}default:throw new Error(`[SX] parseInitialState: Invalid syntax at: ${m(e)}.`)}_(e),n=p(e)}return t}var E=n("43fb"),N=function(e,t,n,r){function o(e){return e instanceof n?e:new n((function(t){t(e)}))}return new(n||(n=Promise))((function(n,a){function s(e){try{c(r.next(e))}catch(t){a(t)}}function l(e){try{c(r["throw"](e))}catch(t){a(t)}}function c(e){e.done?n(e.value):o(e.value).then(s,l)}c((r=r.apply(e,t||[])).next())}))};function I(e,t,n,r){return{strings:"string"===typeof n?[n]:n,values:r||[],index:0,pos:0,line:0,evalCount:0,scopes:[{isBlockLocal:!1,scope:t}],macroMap:new Map(e.macros.map(e=>[e.name,e])),funcMap:new Map(e.funcs.map(e=>[e.name,e])),symbolMap:new Map(e.symbols.map(e=>[e.name,e])),config:e}}function k(e,t,n){return e.strings="string"===typeof t?[t]:t,e.values=n||[],e.index=0,e.pos=0,e.line=0,e.evalCount=0,e}function T(e){let t=e||Object.assign({},s),n={},r=[];const o=(e,n)=>{if(t.enableEvaluate)for(let t=0;t<n.length;t++)n[t]=Object(E["b"])(e,n[t]);return t.returnMultipleRoot?1===n.length?n[0]:n:n[n.length-1]},a=(e,...a)=>{const s=I(t,Object.assign({},n),e,a);return o(s,r.concat(A(s)))};return a.evaluateAST=e=>{const a=I(t,Object.assign({},n),"");return o(a,r.concat(e))},a.repl=()=>{const e=I(t,Object.assign({},n),"");o(e,r.slice(0));const a=(t,...n)=>(k(e,t,n),o(e,A(e)));return a.sync=a,a},a.setGlobals=e=>(n=Object.assign({},e||{}),a),a.appendGlobals=e=>(n=Object.assign({},n,e||{}),a),a.setStartup=(e,...o)=>{const s=I(t,Object.assign({},n),e,o);return r=A(s),a},a.setStartupAST=e=>(r=e,a),a.appendStartup=(e,...o)=>{const s=I(t,Object.assign({},n),e,o);return r=r.concat(A(s)),a},a.appendStartupAST=e=>(r=r.concat(e),a),a.install=e=>(t=e(t),a),a}function X(e){let t=e||Object.assign({},s),n={},r=[];const o=(e,n)=>N(this,void 0,void 0,(function*(){if(t.enableEvaluate)for(let t=0;t<n.length;t++)n[t]=Object(E["b"])(e,n[t]),"object"===typeof n[t]&&null!==n[t]&&"function"===typeof n[t].then&&(n[t]=yield n[t]);return t.returnMultipleRoot?1===n.length?n[0]:n:n[n.length-1]})),a=(e,...a)=>N(this,void 0,void 0,(function*(){const s=I(t,Object.assign({},n),e,a);return o(s,r.concat(A(s)))}));return a.evaluateAST=e=>{const a=I(t,Object.assign({},n),"");return o(a,r.concat(e))},a.repl=()=>{const e=(e,n)=>{if(t.enableEvaluate)for(let t=0;t<n.length;t++)n[t]=Object(E["b"])(e,n[t]);return t.returnMultipleRoot?1===n.length?n[0]:n:n[n.length-1]},a=I(t,Object.assign({},n),"");o(a,r.slice(0));const s=(e,...t)=>N(this,void 0,void 0,(function*(){return k(a,e,t),o(a,A(a))})),l=(t,...n)=>(k(a,t,n),e(a,A(a)));return s.sync=l,s},a.setGlobals=e=>(n=Object.assign({},e||{}),a),a.appendGlobals=e=>(n=Object.assign({},n,e||{}),a),a.setStartup=(e,...o)=>{const s=I(t,Object.assign({},n),e,o);return r=A(s),a},a.setStartupAST=e=>(r=e,a),a.appendStartup=(e,...o)=>{const s=I(t,Object.assign({},n),e,o);return r=r.concat(A(s)),a},a.appendStartupAST=e=>(r=r.concat(e),a),a.install=e=>(t=e(t),a),a}const x=(()=>{const e=Object.assign({},s);return e.enableEvaluate=!1,e.returnMultipleRoot=!0,T(e)})();var C=n("6921"),M=n("7941"),P=n("6977");const D=(e,t)=>(...e)=>{Object(P["a"])("$car",e,1,1);const t=R(...e);if(!Array.isArray(t))throw new Error("[SX] $car: Invalid argument(s): args[0] is not array.");if(0===t.length)throw new Error("[SX] $car: Invalid argument(s): args[0] is nil.");return t[0]},L=(D(null,null),(e,t)=>(...e)=>{Object(P["a"])("$cdr",e,1,1);const t=R(...e);if(!Array.isArray(t))throw new Error("[SX] $cdr: Invalid argument(s): args[0] is not array.");if(0===t.length)throw new Error("[SX] $cdr: Invalid argument(s): args[0] is nil.");return t.slice(1)}),q=(L(null,null),(e,t)=>(...e)=>{Object(P["a"])("$cons",e,2,2);let{car:t,cdr:n}=G(...e);return null===t&&(t=[]),null===n&&(n=[]),Array.isArray(n)?(n=n.slice(0),n.unshift(t),n):{car:t,cdr:n}}),U=(q(null,null),(e,t)=>(...e)=>{const t=e.slice(0,1);return 1===t.length?t[0]:null}),R=U(null,null),F=(e,t)=>(...e)=>{const t=e.slice(1,2);return 1===t.length?t[0]:null},B=F(null,null),W=(e,t)=>(...e)=>{const t=e.slice(e.length-1,e.length);return 1===t.length?t[0]:null},K=(W(null,null),(e,t)=>(...e)=>{const t=e.slice(1);return 0<t.length?t:null}),V=(K(null,null),(e,t)=>(...e)=>{let t=e.slice(0,1);t=1===t.length?t[0]:null;let n=e.slice(1,2);return n=1===n.length?n[0]:null,{car:t,cdr:n}}),G=V(null,null),J=(e,t)=>(...e)=>{Object(P["a"])("$atom",e,1,1);const t=R(...e);if(null===t||void 0===t)return!0;if(Array.isArray(t))return 0===t.length;switch(typeof t){case"number":case"string":case"function":case"boolean":return!0;case"object":return!!Object(o["d"])(t)}return!1},H=(J(null,null),(e,t)=>(...e)=>{Object(P["a"])("$eq",e,2,2);const{car:t,cdr:n}=G(...e);return t===n}),z=(H(null,null),(e,t)=>(...e)=>{Object(P["a"])("$notEq",e,2,2);const{car:t,cdr:n}=G(...e);return t!==n}),Y=(z(null,null),(e,t)=>(...e)=>e.slice(0)),Q=(Y(null,null),(e,t,n)=>(...t)=>{Object(P["a"])("$__scope",t,3);const r=R(...t),a=B(...t),{car:s,cdr:l}=G(...t.slice(2));let c=null;const i={};if(Array.isArray(s))for(const n of s)if(Array.isArray(n)){const t=G(...n),r=Object(o["d"])(t.car),a=r?r.symbol:String(t.car);Object(P["c"])("$__scope",i,a),i[a]=Object(E["b"])(e,t.cdr)}else{const e=Object(o["d"])(n),t=e?e.symbol:String(n);Object(P["c"])("$__scope",i,t),i[t]=null}Object(E["f"])(e,i,r,n);try{if(4<t.length)if(a){c=[];for(const n of t.slice(3))c.push(Object(E["b"])(e,n))}else for(const n of t.slice(3))c=Object(E["b"])(e,n);else c=Object(E["b"])(e,l)}finally{Object(E["m"])(e)}return c}),Z=(e,t)=>(...t)=>{Object(P["a"])("$__globalScope",t,1);const n=R(...t),r=B(...t);let o=null;Object(E["f"])(e,Object(E["d"])(e).scope,!0);try{if(2<t.length)if(n){o=[];for(const n of t.slice(1))o.push(Object(E["b"])(e,n))}else for(const n of t.slice(1))o=Object(E["b"])(e,n);else o=Object(E["b"])(e,r)}finally{Object(E["m"])(e)}return o},ee=(e,t)=>(...t)=>{Object(P["a"])("$__capture",t,1);const n=t[0];if(!Array.isArray(n))throw new Error("[SX] $__lambda: Invalid argument(s): args[0] is not array.");let r=null;const o=Object(E["a"])(e,n);Object(E["f"])(e,{},!0,o);try{for(const n of t.slice(1))r=Object(E["b"])(e,n)}finally{Object(E["m"])(e)}return r},te=(e,t)=>(...n)=>{Object(P["a"])("$__lambda",n,2);const r=n[0];if(!Array.isArray(r))throw new Error("[SX] $__lambda: Invalid argument(s): args[0] is not array.");let a=!1;for(let t=0;t<r.length;t++){const n=r[t];if(t===r.length-1&&e.config.enableSpread&&Array.isArray(n)&&Object(o["d"])(n[0],e.config.reservedNames.spread)){if(!Object(o["d"])(n[1]))throw new Error(`[SX] $__lambda: Invalid formal argument(s): item(s) of args[${t}] is not symbol.`);r[t]=n[1],a=!0}else if(!Object(o["d"])(n))throw new Error(`[SX] $__lambda: Invalid formal argument(s): item(s) of args[${t}] is not symbol.`)}let s=n.slice(1);e.config.enableTailCallOptimization&&(s=Object(E["g"])(e,r,s));const l=Object(E["c"])(e),c=function(...n){if(n.length+(a?1:0)<r.length)throw new Error(`[SX] func call: Actual args too short: actual ${n.length} / formal ${r.length}.`);return Q(e,t,l)(!1,!1,[[e.config.reservedNames.self,c],[e.config.reservedNames.thiz,this===C["a"]||void 0===this?null:Object(o["f"])(e,this)],...r.map((t,s)=>[t.symbol,Object(o["f"])(e,a&&s===r.length-1?n.slice(s):n[s])])],...s)};return c},ne=(e,t)=>(...t)=>{Object(P["a"])("$$__lambda",t,2);const n=t[0];if(!Array.isArray(n))throw new Error("[SX] $$__lambda: Invalid argument(s): args[0] is not array.");let r=!1;for(let s=0;s<n.length;s++){const t=n[s];if(s===n.length-1&&e.config.enableSpread&&Array.isArray(t)&&Object(o["d"])(t[0],e.config.reservedNames.spread)){if(!Object(o["d"])(t[1]))throw new Error(`[SX] $$__lambda: Invalid formal argument(s): item(s) of args[${s}] is not symbol.`);n[s]=t[1],r=!0}else if(!Object(o["d"])(t))throw new Error(`[SX] $$__lambda: Invalid formal argument(s): item(s) of args[${s}] is not symbol.`)}const a=t.slice(1);return Object(M["a"])(e,n,r,a)},re=(e,t)=>(...n)=>{Object(P["a"])("$__defun",n,3);const r=R(...n),o=te(e,t)(...n.slice(1));return Object(P["c"])("$__defun",e.funcMap,r.symbol),e.funcMap.set(r.symbol,{name:r.symbol,fn:(e,t)=>o}),o},oe=(e,t)=>(...n)=>{Object(P["a"])("$$__defun",n,3);const r=R(...n),o=ne(e,t)(...n.slice(1));return Object(P["c"])("$$__defun",e.funcMap,r.symbol),e.funcMap.set(r.symbol,{name:r.symbol,fn:(e,t)=>o}),o},ae=(e,t)=>(...t)=>{Object(P["a"])("$__refun",t,1,1);const n=R(...t);Object(P["c"])("$__refun",e.funcMap,n.symbol);const r=e.funcMap.get(n.symbol);if(!r)throw new Error(`[SX] $__refun: function ${n.symbol} is not defined.`);return r.fn(e,n.symbol)},se=(e,t)=>(...n)=>{Object(P["a"])("$__defmacro",n,3);const r=R(...n),a=n[1];if(!Array.isArray(a))throw new Error("[SX] $__defmacro: Invalid argument(s): args[1] is not array.");let s=!1;for(let t=0;t<a.length;t++){const n=a[t];if(t===a.length-1&&e.config.enableSpread&&Array.isArray(n)&&Object(o["d"])(n[0],e.config.reservedNames.spread)){if(!Object(o["d"])(n[1]))throw new Error(`[SX] $__defmacro: Invalid formal argument(s): item(s) of args[${t}] is not symbol.`);a[t]=n[1],s=!0}else if(!Object(o["d"])(n))throw new Error(`[SX] $__defmacro: Invalid formal argument(s): item(s) of args[${t}] is not symbol.`)}const l=n.slice(2),c=Object(E["c"])(e),i=n=>(...r)=>Q(e,t,c)(!1,!1,[[e.config.reservedNames.self,i],...n.map((t,a)=>[t.symbol,Object(o["f"])(e,s&&a===n.length-1?r.slice(a):r[a])])],...l),u={name:r.symbol,fn:(e,t,n)=>e=>i(n)(...e.slice(1)),formalArgs:a,lastIsSpread:s};if(Object(P["c"])("$__defmacro",e.macroMap,r.symbol),e.macroMap.has(r.symbol)){let t=e.macroMap.get(r.symbol);if(t.next=u,t&&t.formalArgs)if(t.formalArgs.length<a.length)e.macroMap.set(r.symbol,u),u.next=t;else{let e=t;t=t.next;while(t){if(t.formalArgs&&t.formalArgs.length<a.length){e.next=u,u.next=t;break}e=t,t=t.next}}}else e.macroMap.set(r.symbol,u);return i},le=(e,t)=>(...e)=>{Object(P["a"])("$apply",e,1);const t=R(...e);if("function"!==typeof t)throw new Error("[SX] $apply: Invalid argument(s): args[0] is not function.");return(...n)=>t.apply(null,e.slice(1).concat(n))},ce=(le(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__call",t,2);const{car:n,cdr:r}=G(...t),a=Object(o["d"])(r),s=a?a.symbol:Object(E["b"])(e,r);return Object(P["c"])("$__call",n,s),Function.prototype.apply.call(n[s],n,t.slice(2))}),ie=(e,t)=>(...n)=>{Object(P["a"])("$__try",n,1,2);let a=[];try{a=Object(E["b"])(e,n[0])}catch(s){if(s instanceof r["a"])throw s;a=1<n.length?Q(e,t)(!0,!1,[["$error",Object(o["f"])(e,s)],["$parent",Object(o["f"])(e,Object(E["e"])(e))]],n[1]):null}return a},ue=(e,t)=>(...e)=>{const t=R(...e);throw t},fe=(ue(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__if",t,2,3);const n=R(...t);let r=[];return r=Se(n)?Object(E["b"])(e,t[1]):2<t.length?Object(E["b"])(e,t[2]):null,r}),me=(e,t)=>(...t)=>{Object(P["a"])("$__ifNull",t,2,2);const{car:n,cdr:r}=G(...t);let o=[];return o=Te(n,null)?Object(E["b"])(e,r):n,o},be=(e,t)=>(...t)=>{Object(P["a"])("$__cond",t,1);for(let n=0;n<t.length-1;n+=2){const r=t[n],o=t[n+1];if(Se(Object(E["b"])(e,r)))return Object(E["b"])(e,o)}return null},$e=(e,t)=>(...t)=>{Object(P["a"])("$__while",t,1);const n=R(...t),r=t.slice(1);let o=null;while(Se(Object(E["b"])(e,n)))for(const t of r)o=Object(E["b"])(e,t);return o},pe=(e,t)=>(...t)=>{Object(P["a"])("$__doWhile",t,1);const n=R(...t),r=t.slice(1);let o=null;do{for(const t of r)o=Object(E["b"])(e,t)}while(Se(Object(E["b"])(e,n)));return o},_e=(e,t)=>(...t)=>{Object(P["a"])("$__until",t,1);const n=R(...t),r=t.slice(1);let o=null;while(Ee(Object(E["b"])(e,n)))for(const t of r)o=Object(E["b"])(e,t);return o},de=(e,t)=>(...t)=>{Object(P["a"])("$__doUntil",t,1);const n=R(...t),r=t.slice(1);let o=null;do{for(const t of r)o=Object(E["b"])(e,t)}while(Ee(Object(E["b"])(e,n)));return o},ye=(e,t)=>(...t)=>{Object(P["a"])("$__repeat",t,2);const n=Object(o["d"])(R(...t));if(!n)throw new Error("[SX] $__repeat: Invalid argument(s): item(s) of args[0] is not symbol.");Object(P["c"])("$__repeat",{},n.symbol);const r=Object(E["k"])(e,n,!1),a=Object(E["l"])(B(...t)),s=t.slice(2);let l=null;for(let o=0;o<a;o++){r[n.symbol]=o;for(const t of s)l=Object(E["b"])(e,t)}return l},ge=(e,t)=>(...t)=>{Object(P["a"])("$__for",t,2);const n=Object(o["d"])(R(...t));if(!n)throw new Error("[SX] $__for: Invalid argument(s): item(s) of args[0] is not symbol.");Object(P["c"])("$__for",{},n.symbol);const r=Object(E["k"])(e,n,!1),a=B(...t);if(!Array.isArray(a))throw new Error("[SX] $__for: Invalid argument(s): item(s) of args[1] is not array.");const s=t.slice(2);let l=null;for(const o of a){r[n.symbol]=o;for(const t of s)l=Object(E["b"])(e,t)}return l},je=(e,t)=>(...e)=>{Object(P["a"])("$pipe",e,1);let t=e[0];for(let n=1;n<e.length;n++)t=e[n](t);return t},Oe=(je(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__get",t,1);let n=null,r=Object(o["d"])(t[0]);if(!r)switch(typeof t[0]){case"string":case"number":r={symbol:String(t[0])};break;default:n=Object(E["b"])(e,t[0]);break}if(r){const t=Object(E["k"])(e,r,!0);if(!t)throw new Error(`[SX] $__get: Invalid argument(s): args[0]: symbol "${r.symbol}" is not defined.`);n=t[r.symbol]}for(let a=1;a<t.length;a++){let s=t[a],l=!0;while(l)switch(typeof s){case"function":n=s(n),l=!1;break;case"object":if(Array.isArray(s))s=Object(E["b"])(e,s);else if(r=Object(o["d"])(s),r)s=r.symbol;else{if(!Object.prototype.hasOwnProperty.call(s,"value"))throw new Error("[SX] $__get: Invalid argument(s): invalid name path.");s=Object(E["b"])(e,s)}break;case"number":s<0&&(s=n.length+s);case"string":Object(P["c"])("$__get",n,s),n=n[s],l=!1;break;default:throw new Error("[SX] $__get: Invalid argument(s): invalid name path.")}}return n}),he=(e,t)=>(...t)=>{Object(P["a"])("$__let",t,2,2);let n=Object(o["d"])(R(...t));if(!n){if("string"!==typeof t[0])throw new Error("[SX] $__let: Invalid argument(s): invalid name.");n={symbol:t[0]}}Object(P["c"])("$__let",{},n.symbol);const r=Object(E["k"])(e,n,!1);return r[n.symbol]=t[1],t[1]},ve=(e,t)=>(...t)=>{Object(P["a"])("$__set",t,2,2);let n=[];Array.isArray(t[0])?n=t[0]:n.push(t[0]);let r=Object(o["d"])(n[0]);if(!r){if("string"!==typeof n[0])throw new Error("[SX] $__set: Invalid argument(s): invalid name.");Object(P["c"])("$__set",{},n[0]),r={symbol:n[0]}}let a=Object(E["k"])(e,r,!0);if(null===a)throw new Error(`[SX] $__set: Unresolved symbol: ${r.symbol}.`);let s=!1;for(let l=0;l<n.length;l++){let c=n[l],i=!0;const u=l===n.length-1;while(i)switch(typeof c){case"function":a=c(a),i=!1;break;case"object":if(Array.isArray(c))c=Object(E["b"])(e,c);else if(r=Object(o["d"])(c),r)c=r.symbol;else{if(!Object.prototype.hasOwnProperty.call(c,"value"))throw new Error("[SX] $__set: Invalid argument(s): invalid name.");c=Object(E["b"])(e,c)}break;case"number":c<0&&(c=a.length+c);case"string":Object(P["c"])("$__set",a,c),u?(a[c]=t[1],s=!0):a=a[c],i=!1;break;default:throw new Error("[SX] $__set: Invalid argument(s): invalid name.")}}if(!s)throw new Error("[SX] $__set: Invalid argument(s): last path is not lvalue.");return t[1]},we=(e,t)=>(...e)=>{Object(P["a"])("$boolean",e,1,1);const t=R(...e);return(!Array.isArray(t)||0!==t.length)&&Boolean(t)},Se=we(null,null),Ae=(e,t)=>(...e)=>(Object(P["a"])("$not",e,1,1),!Se(...e)),Ee=Ae(null,null),Ne=(e,t)=>(...t)=>{Object(P["a"])("$__and",t,1);let n=null;for(let r=0;r<t.length;r++){const o=Object(E["b"])(e,t[r]);if(!Se(o))return o;n=o}return n},Ie=(Ne(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__or",t,1);let n=null;for(let r=0;r<t.length;r++){const o=Object(E["b"])(e,t[r]);if(Se(o))return o;n=o}return n}),ke=(Ie(null,null),(e,t)=>(...e)=>{Object(P["a"])("$ambiguousEq",e,2,2);let{car:t,cdr:n}=G(...e);return Array.isArray(t)&&0===t.length&&(t=null),Array.isArray(n)&&0===n.length&&(n=null),void 0===t&&(t=null),void 0===n&&(n=null),t==n}),Te=ke(null,null),Xe=(e,t)=>(...e)=>!Te(...e),xe=(Xe(null,null),(e,t)=>(...e)=>{Object(P["a"])("$lt",e,2,2);const{car:t,cdr:n}=G(...e);return Object(E["l"])(t)<Object(E["l"])(n)}),Ce=(xe(null,null),(e,t)=>(...e)=>{Object(P["a"])("$le",e,2,2);const{car:t,cdr:n}=G(...e);return Object(E["l"])(t)<=Object(E["l"])(n)}),Me=(Ce(null,null),(e,t)=>(...e)=>{Object(P["a"])("$gt",e,2,2);const{car:t,cdr:n}=G(...e);return Object(E["l"])(t)>Object(E["l"])(n)}),Pe=(Me(null,null),(e,t)=>(...e)=>{Object(P["a"])("$ge",e,2,2);const{car:t,cdr:n}=G(...e);return Object(E["l"])(t)>=Object(E["l"])(n)}),De=(Pe(null,null),(e,t)=>(...e)=>{Object(P["a"])("$typeof",e,1,1);const t=R(...e);if(null===t)return"null";const n=typeof t;switch(n){case"object":return Array.isArray(t)?"list":"object";case"symbol":return"js-symbol";default:return n}}),Le=(De(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$symbol",e,1,1),"string"===typeof e[0])return{symbol:e[0]};throw new Error("[SX] $symbol: Invalid argument(s): item(s) of args[0] is not string.")}),qe=(Le(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__gensym",t,0,1);const n=`$__tempvar__$$ec${e.evalCount++}$$_`,r={symbol:n+"_$gensym"};if(1===t.length){const n=Object(o["d"])(t[0]);if(n)he(e,"")(n,r);else{if("string"!==typeof t[0])throw new Error("[SX] $__gensym: Invalid argument(s): item(s) of args[0] is not symbol.");he(e,"")({symbol:t[0]},r)}}return r}),Ue=(e,t)=>(...e)=>{if(Object(P["a"])("$isSymbol",e,1,2),1===e.length)return!!Object(o["d"])(e[0]);if("string"===typeof e[1])return!!Object(o["d"])(e[0],e[1]);throw new Error("[SX] $isSymbol: Invalid argument(s): item(s) of args[1] is not string.")},Re=(Ue(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isNull",e,1,1),null===R(...e))),Fe=(Re(null,null),(e,t)=>(...e)=>{Object(P["a"])("$isNil",e,1,1);const t=R(...e);return Array.isArray(t)&&0===t.length}),Be=(Fe(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isUndefined",e,1,1),void 0===R(...e))),We=(Be(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isList",e,1,1),Array.isArray(R(...e)))),Ke=(We(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isString",e,1,1),"string"===typeof R(...e))),Ve=(Ke(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isNumber",e,1,1),"number"===typeof R(...e))),Ge=(Ve(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isNaN",e,1,1),Number.isNaN(R(...e)))),Je=(Ge(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isFinite",e,1,1),Number.isFinite(R(...e)))),He=(Je(null,null),(e,t)=>(...e)=>(Object(P["a"])("$isInteger",e,1,1),Number.isInteger(R(...e)))),ze=(He(null,null),(e,t)=>(...e)=>(Object(P["a"])("$toString",e,1,1),String(R(...e)))),Ye=(ze(null,null),(e,t)=>(...e)=>(Object(P["a"])("$toNumber",e,1,1),Object(E["l"])(R(...e)))),Qe=(Ye(null,null),(e,t)=>(...t)=>{const n={};for(const r of t){if(!(Array.isArray(r)&&0<r.length))throw new Error("[SX] $__toObject: Invalid argument(s): args[?] is not array.");{const t=Object(o["d"])(r[0]),a=t?t.symbol:String(Object(E["b"])(e,r[0]));Object(P["c"])("$__#",n,a),1===r.length?n[a]=!0:2===r.length?n[a]=Object(E["b"])(e,r[1]):n[a]=Object(E["b"])(e,[{symbol:e.config.reservedNames.list}].concat(r.slice(1)))}}return n}),Ze=[C["a"],Object.__proto__,{}.__proto__,Function.__proto__],et=(e,t)=>(...e)=>{if(Object(P["a"])("$objectAssign",e,1),Ze.includes(e[0]))throw new Error("[SX] $objectAssign: Invalid argument: args[0] is blacklisted object.");return Object.assign(e[0],...e.slice(1))},tt=(et(null,null),(e,t)=>(...e)=>(Object(P["a"])("$jsonStringify",e,1,1),JSON.stringify(R(...e)))),nt=(tt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$jsonParse",e,1,1);const t=R(...e);if("string"!==typeof t)throw new Error("[SX] $jsonParse: Invalid argument(s): args[0] is not string.");return JSON.parse(t)}),rt=(nt(null,null),(e,t)=>(...e)=>Date.now()),ot=(rt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetimeFromIso",e,1,1);const t=R(...e);if("string"!==typeof t)throw new Error("[SX] $datetimeFromIso: Invalid argument(s): args[0] is not string.");if(!/^(?:(?:-[0-9]{6,})|[0-9]{4,})-(?:[0-1][0-9])-(?:[0-3][0-9])(?:T(?:[0-2][0-9])(?:[:](?:[0-6][0-9])(?:[:](?:[0-6][0-9])(?:.[0-9]{1,})?)?)?(?:Z|[-+][0-9]{2}(?:[:]?[0-6][0-9])?)?)?$/.test(t))throw new Error(`[SX] $datetimeFromIso: Invalid datetime (pattern unmatched): ${t}.`);const n=new Date(t).getTime();if(Number.isNaN(n))throw new Error(`[SX] $datetimeFromIso: Invalid datetime: ${t}.`);return n}),at=(ot(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetime",e,3,7);let t="";const n=Number(e[0]);t+=n>=0?String(n).padStart(4,"0"):"-"+String(-n).padStart(6,"0"),t+="-"+String(Number(e[1])).padStart(2,"0"),t+="-"+String(Number(e[2])).padStart(2,"0"),e.length>=4&&(t+="T"+String(Number(e[3])).padStart(2,"0"),e.length>=5?t+=":"+String(Number(e[4])).padStart(2,"0"):t+=":00",e.length>=6&&(t+=":"+String(Number(e[5])).padStart(2,"0")),e.length>=7&&(t+="."+String(Number(e[6])).padStart(3,"0").slice(0,3)),t+="Z");const r=new Date(t).getTime();if(Number.isNaN(r))throw new Error(`[SX] $datetime: Invalid datetime: ${t}.`);return r}),st=(at(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetimeLc",e,3,7);let t="";const n=Number(e[0]);t+=n>=0?String(n).padStart(4,"0"):"-"+String(-n).padStart(6,"0"),t+="-"+String(Number(e[1])).padStart(2,"0"),t+="-"+String(Number(e[2])).padStart(2,"0"),e.length>=4?(t+="T"+String(Number(e[3])).padStart(2,"0"),e.length>=5?t+=":"+String(Number(e[4])).padStart(2,"0"):t+=":00",e.length>=6&&(t+=":"+String(Number(e[5])).padStart(2,"0")),e.length>=7&&(t+="."+String(Number(e[6])).padStart(3,"0").slice(0,3))):t+="T00:00:00.000";const r=new Date(t).getTime();if(Number.isNaN(r))throw new Error(`[SX] $datetimeLc: Invalid datetime: ${t}.`);return r}),lt=(st(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetimeToIsoString",e,1,1);const t=R(...e);if("number"!==typeof t)throw new Error("[SX] $datetimeToIsoString: Invalid argument(s): args[0] is not number.");const n=new Date(t);if(Number.isNaN(n.getTime()))throw new Error(`[SX] $datetimeToIsoString: Invalid datetime: ${t}.`);return n.toISOString()}),ct=(lt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetimeToComponents",e,1,1);const t=R(...e);if("number"!==typeof t)throw new Error("[SX] $datetimeToComponents: Invalid argument(s): args[0] is not number.");const n=new Date(t);if(Number.isNaN(n.getTime()))throw new Error(`[SX] $datetimeToComponents: Invalid datetime: ${t}.`);return[n.getUTCFullYear(),n.getUTCMonth()+1,n.getUTCDate(),n.getUTCHours(),n.getUTCMinutes(),n.getUTCSeconds(),n.getUTCMilliseconds(),0,n.getUTCDay()]}),it=(ct(null,null),(e,t)=>(...e)=>{Object(P["a"])("$datetimeToComponentsLc",e,1,1);const t=R(...e);if("number"!==typeof t)throw new Error("[SX] $datetimeToComponentsLc: Invalid argument(s): args[0] is not number.");const n=new Date(t);if(Number.isNaN(n.getTime()))throw new Error(`[SX] $datetimeToComponentsLc: Invalid datetime: ${t}.`);return[n.getFullYear(),n.getMonth()+1,n.getDate(),n.getHours(),n.getMinutes(),n.getSeconds(),n.getMilliseconds(),-n.getTimezoneOffset(),n.getDay()]}),ut=(it(null,null),(e,t)=>(...t)=>{if(Object(P["a"])("$match",t,2,3),!e.config.enableRegExpMatchOperators)throw new Error("[SX] $match: Operator is disabled by configuration.");if(2===t.length){const e=new RegExp(t[0]);return e.exec(t[1])}{const e=new RegExp(t[0],t[1]);return e.exec(t[2])}}),ft=(ut(null,null),(e,t)=>(...e)=>(console.log(...e),null)),mt=(ft(null,null),(e,t)=>(...e)=>(console.error(...e),null)),bt=(mt(null,null),(e,t)=>(...e)=>(console.trace(...e),null)),$t=(bt(null,null),(e,t)=>(...e)=>(console.time(...e),null)),pt=($t(null,null),(e,t)=>(...e)=>(console.timeEnd(...e),null)),_t=(pt(null,null),(e,t)=>(...e)=>(console.timeLog(...e),null)),dt=(_t(null,null),[{name:"$car",fn:D},{name:"$cdr",fn:L},{name:"$cons",fn:q},{name:"$first",fn:U},{name:"$second",fn:F},{name:"$last",fn:W},{name:"$progn",fn:W},{name:"$rest",fn:K},{name:"$first-and-second",fn:V},{name:"$atom",fn:J},{name:"$eq",fn:H},{name:"===",fn:H},{name:"$not-eq",fn:z},{name:"!==",fn:z},{name:"$list",fn:Y},{name:"$__scope",fn:Q},{name:"$__global",fn:Z},{name:"$__capture",fn:ee},{name:"$__lambda",fn:te},{name:"$__defun",fn:re},{name:"$__refun",fn:ae},{name:"$__defmacro",fn:se},{name:"$apply",fn:le},{name:"$__call",fn:ce},{name:"$__try",fn:ie},{name:"$raise",fn:ue},{name:"$__if",fn:fe},{name:"$__if-null",fn:me},{name:"$__cond",fn:be},{name:"$__while",fn:$e},{name:"$__do-while",fn:pe},{name:"$__until",fn:_e},{name:"$__do-until",fn:de},{name:"$__repeat",fn:ye},{name:"$__for",fn:ge},{name:"$pipe",fn:je},{name:"$__get",fn:Oe},{name:"$__let",fn:he},{name:"$__set",fn:ve},{name:"$boolean",fn:we},{name:"$not",fn:Ae},{name:"$__and",fn:Ne},{name:"$__or",fn:Ie},{name:"==",fn:ke},{name:"!=",fn:Xe},{name:"<",fn:xe},{name:"<=",fn:Ce},{name:">",fn:Me},{name:">=",fn:Pe},{name:"$typeof",fn:De},{name:"$symbol",fn:Le},{name:"$__gensym",fn:qe},{name:"$is-symbol",fn:Ue},{name:"$is-null",fn:Re},{name:"$is-nil",fn:Fe},{name:"$is-undefined",fn:Be},{name:"$is-list",fn:We},{name:"$is-string",fn:Ke},{name:"$is-number",fn:Ve},{name:"$is-NaN",fn:Ge},{name:"$is-finite",fn:Je},{name:"$is-integer",fn:He},{name:"$to-string",fn:ze},{name:"$to-number",fn:Ye},{name:"$__#",fn:Qe},{name:"$object-assign",fn:et},{name:"$json-stringify",fn:tt},{name:"$now",fn:rt},{name:"$datetime-from-iso",fn:ot},{name:"$datetime",fn:at},{name:"$datetime-lc",fn:st},{name:"$datetime-to-iso-string",fn:lt},{name:"$datetime-to-components",fn:ct},{name:"$datetime-to-components-lc",fn:it},{name:"$json-parse",fn:nt},{name:"$match",fn:ut},{name:"$console-log",fn:ft},{name:"$console-error",fn:mt},{name:"$console-trace",fn:bt},{name:"$console-time",fn:$t},{name:"$console-time-end",fn:pt},{name:"$console-time-log",fn:_t}]),yt=[{name:"$$__lambda",fn:ne},{name:"$$__defun",fn:oe}];var gt=[].concat(dt,yt);const jt=[{name:"$scope",fn:(e,t)=>t=>[{symbol:"$__scope"},t[1],t[2],...t.slice(3).map(t=>Object(o["f"])(e,t))]},{name:"$local",fn:(e,t)=>t=>[{symbol:"$__scope"},!0,!1,...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$global",fn:(e,t)=>t=>[{symbol:"$__global"},!1,...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$clisp-let",fn:(e,t)=>t=>[{symbol:"$__scope"},!0,!1,...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$capture",fn:(e,t)=>t=>[{symbol:"$__capture"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$closure",fn:(e,t)=>t=>{const n=Object(o["d"])(t[2],"use");if(!n)throw new Error("[SX] $closure: Invalid syntax: missing 'use' keyword.");return[{symbol:"$__capture"},Object(o["f"])(e,t[3]),Object(o["f"])(e,[{symbol:"$__lambda"},Object(o["f"])(e,t[1]),...t.slice(4).map(t=>Object(o["f"])(e,t))])]}},{name:"|->",fn:(e,t)=>e=>[{symbol:"$closure"},...e.slice(1)]},{name:"$lambda",fn:(e,t)=>t=>[{symbol:"$__lambda"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"->",fn:(e,t)=>t=>[{symbol:"$__lambda"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$defun",fn:(e,t)=>t=>[{symbol:"$__defun"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$refun",fn:(e,t)=>t=>[{symbol:"$__refun"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"<-",fn:(e,t)=>t=>[{symbol:"$__refun"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$defmacro",fn:(e,t)=>t=>[{symbol:"$__defmacro"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$call",fn:(e,t)=>t=>(Object(P["a"])("$call",t,3),[{symbol:"$__call"},t[1],Object(o["f"])(e,t[2]),...t.slice(3)])},{name:"$try",fn:(e,t)=>t=>[{symbol:"$__try"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$if",fn:(e,t)=>t=>[{symbol:"$__if"},t[1],...t.slice(2).map(t=>Object(o["f"])(e,t))]},{name:"$if-null",fn:(e,t)=>t=>[{symbol:"$__if-null"},t[1],...t.slice(2).map(t=>Object(o["f"])(e,t))]},{name:"??",fn:(e,t)=>t=>[{symbol:"$__if-null"},t[1],...t.slice(2).map(t=>Object(o["f"])(e,t))]},{name:"$cond",fn:(e,t)=>t=>[{symbol:"$__cond"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$while",fn:(e,t)=>t=>[{symbol:"$__while"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$do-while",fn:(e,t)=>t=>[{symbol:"$__do-while"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$until",fn:(e,t)=>t=>[{symbol:"$__until"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$do-until",fn:(e,t)=>t=>[{symbol:"$__do-until"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$repeat",fn:(e,t)=>t=>{const n=Object(o["d"])(t[2],"of");if(!n)throw new Error("[SX] $repeat: Invalid syntax: missing 'of' keyword.");return[{symbol:"$__repeat"},Object(o["f"])(e,t[1]),t[3],...t.slice(4).map(t=>Object(o["f"])(e,t))]}},{name:"$for",fn:(e,t)=>t=>{const n=Object(o["d"])(t[2],"of");if(!n)throw new Error("[SX] $for: Invalid syntax: missing 'of' keyword.");return[{symbol:"$__for"},Object(o["f"])(e,t[1]),t[3],...t.slice(4).map(t=>Object(o["f"])(e,t))]}},{name:"$get",fn:(e,t)=>t=>[{symbol:"$__get"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$let",fn:(e,t)=>t=>(Object(P["a"])("$let",t,3,3),[{symbol:"$__let"},Object(o["f"])(e,t[1]),t[2]])},{name:"$clisp-defvar",fn:(e,t)=>t=>(Object(P["a"])("$clisp-defvar",t,3,3),[{symbol:"$global"},[{symbol:"$__let"},Object(o["f"])(e,t[1]),t[2]]])},{name:"$set",fn:(e,t)=>t=>(Object(P["a"])("$set",t,3,3),[{symbol:"$__set"},Object(o["f"])(e,t[1]),t[2]])},{name:"$clisp-setq",fn:(e,t)=>t=>(Object(P["a"])("$clisp-setq",t,3,3),[{symbol:"$__set"},Object(o["f"])(e,t[1]),t[2]])},{name:"$and",fn:(e,t)=>t=>[{symbol:"$__and"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$or",fn:(e,t)=>t=>[{symbol:"$__or"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$gensym",fn:(e,t)=>t=>[{symbol:"$__gensym"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"#",fn:(e,t)=>t=>[{symbol:"$__#"},...t.slice(1).map(t=>Object(o["f"])(e,t))]}],Ot=[{name:"$$closure",fn:(e,t)=>t=>{const n=Object(o["d"])(t[2],"use");if(!n)throw new Error("[SX] $closure: Invalid syntax: missing 'use' keyword.");return[{symbol:"$__capture"},Object(o["f"])(e,t[3]),Object(o["f"])(e,[{symbol:"$$__lambda"},Object(o["f"])(e,t[1]),...t.slice(4).map(t=>Object(o["f"])(e,t))])]}},{name:"|=>",fn:(e,t)=>e=>[{symbol:"$$closure"},...e.slice(1)]},{name:"$$lambda",fn:(e,t)=>t=>[{symbol:"$$__lambda"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"=>",fn:(e,t)=>t=>[{symbol:"$$__lambda"},...t.slice(1).map(t=>Object(o["f"])(e,t))]},{name:"$$defun",fn:(e,t)=>t=>[{symbol:"$$__defun"},...t.slice(1).map(t=>Object(o["f"])(e,t))]}];var ht=[].concat(jt,Ot);const vt=[{name:"nil",fn:(e,t)=>[]},{name:"null",fn:(e,t)=>null},{name:"undefined",fn:(e,t)=>{}},{name:"true",fn:(e,t)=>!0},{name:"#true",fn:(e,t)=>!0},{name:"#t",fn:(e,t)=>!0},{name:"false",fn:(e,t)=>!1},{name:"#false",fn:(e,t)=>!1},{name:"#f",fn:(e,t)=>!1},{name:"#Number:Infinity",fn:(e,t)=>Number.POSITIVE_INFINITY},{name:"+Infinity",fn:(e,t)=>Number.POSITIVE_INFINITY},{name:"-Infinity",fn:(e,t)=>Number.NEGATIVE_INFINITY},{name:"#Number:Epsilon",fn:(e,t)=>Number.EPSILON},{name:"#Number:MaxValue",fn:(e,t)=>Number.MAX_VALUE},{name:"#Number:MinValue",fn:(e,t)=>Number.MIN_VALUE},{name:"#Number:MinSafeInteger",fn:(e,t)=>Number.MAX_SAFE_INTEGER},{name:"#Number:MinSafeInteger",fn:(e,t)=>Number.MIN_SAFE_INTEGER},{name:"NaN",fn:(e,t)=>Number.NaN}];var wt=vt;function St(e){return e.funcs=(e.funcs||[]).concat(dt).concat(e.enableCompilationOperators?yt:[]),e.macros=(e.macros||[]).concat(jt).concat(e.enableCompilationOperators?Ot:[]),e.symbols=(e.symbols||[]).concat(wt),e}const At=(e,t)=>(...e)=>{Object(P["a"])("$bitLShift",e,2,2);let{car:t,cdr:n}=G(...e);return t=Object(E["l"])(t),n=Object(E["l"])(n),0<=n?n<32?t<<n:0:n>-32?t>>>-n:0},Et=(At(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitSRShift",e,2,2);let{car:t,cdr:n}=G(...e);return t=Object(E["l"])(t),n=Object(E["l"])(n),0<=n?n<32?t>>n:2147483648&t?-1:0:n>-32?t<<-n:0}),Nt=(Et(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitURShift",e,2,2);let{car:t,cdr:n}=G(...e);return t=Object(E["l"])(t),n=Object(E["l"])(n),0<=n?n<32?t>>>n:0:n>-32?t<<-n:0}),It=(Nt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitNot",e,1,1);const t=R(...e);return~Object(E["l"])(t)}),kt=(It(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitAnd",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)&Object(E["l"])(t),Object(E["l"])(t))}),Tt=(kt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitOr",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)|Object(E["l"])(t),Object(E["l"])(t))}),Xt=(Tt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$bitXor",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)^Object(E["l"])(t),Object(E["l"])(t))}),xt=(Xt(null,null),(e,t)=>(...e)=>(Object(P["a"])("$add",e,1),e.reduce((e,t)=>Object(E["l"])(e)+Object(E["l"])(t),0))),Ct=(xt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$sub",e,1);const t=R(...e),n=e.slice(1);return 0===n.length?-Object(E["l"])(t):e.slice(1).reduce((e,t)=>Object(E["l"])(e)-Object(E["l"])(t),Object(E["l"])(t))}),Mt=(Ct(null,null),(e,t)=>(...e)=>{Object(P["a"])("$mul",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)*Object(E["l"])(t),Object(E["l"])(t))}),Pt=(Mt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$sup",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Math.pow(Object(E["l"])(e),Object(E["l"])(t)),Object(E["l"])(t))}),Dt=(Pt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$div",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)/Object(E["l"])(t),Object(E["l"])(t))}),Lt=(Dt(null,null),(e,t)=>(...e)=>{Object(P["a"])("$mod",e,2);const t=R(...e);return e.slice(1).reduce((e,t)=>Object(E["l"])(e)%Object(E["l"])(t),Object(E["l"])(t))}),qt=(Lt(null,null),(e,t)=>(...e)=>Math.max(...e.map(e=>Object(E["l"])(e)))),Ut=(qt(null,null),(e,t)=>(...e)=>Math.min(...e.map(e=>Object(E["l"])(e)))),Rt=(Ut(null,null),(e,t)=>(...e)=>{const t=e.map(e=>Object(E["l"])(e));return t.length>0?t.reduce((e,t)=>e+t,0)/t.length:NaN}),Ft=(Rt(null,null),(e,t)=>(...e)=>(Object(P["a"])("$floor",e,1,1),Math.floor(Object(E["l"])(R(...e))))),Bt=(Ft(null,null),(e,t)=>(...e)=>(Object(P["a"])("$ceil",e,1,1),Math.ceil(Object(E["l"])(R(...e))))),Wt=(Bt(null,null),(e,t)=>(...e)=>(Object(P["a"])("$round",e,1,1),Math.round(Object(E["l"])(R(...e))))),Kt=(Wt(null,null),(e,t)=>(...e)=>(Object(P["a"])("$abs",e,1,1),Math.abs(Object(E["l"])(R(...e))))),Vt=(Kt(null,null),(e,t)=>(...e)=>(Object(P["a"])("$sign",e,1,1),Math.sign(Object(E["l"])(R(...e))))),Gt=(Vt(null,null),[{name:"<<",fn:At},{name:"$bit-l-shift",fn:At},{name:">>",fn:Et},{name:"$bit-sr-shift",fn:Et},{name:">>>",fn:Nt},{name:"$bit-ur-shift",fn:Nt},{name:"$bit-not",fn:It},{name:"$bit-and",fn:kt},{name:"$bit-or",fn:Tt},{name:"$bit-xor",fn:Xt},{name:"+",fn:xt},{name:"$add",fn:xt},{name:"$sum",fn:xt},{name:"-",fn:Ct},{name:"$sub",fn:Ct},{name:"$neg",fn:Ct},{name:"*",fn:Mt},{name:"$mul",fn:Mt},{name:"**",fn:Pt},{name:"$sup",fn:Pt},{name:"/",fn:Dt},{name:"$div",fn:Dt},{name:"%",fn:Lt},{name:"$mod",fn:Lt},{name:"$max",fn:qt},{name:"$min",fn:Ut},{name:"$avg",fn:Rt},{name:"$floor",fn:Ft},{name:"$ceil",fn:Bt},{name:"$round",fn:Wt},{name:"$abs",fn:Kt},{name:"$sign",fn:Vt}]);var Jt=Gt;const Ht=[{name:"$incl",fn:(e,t)=>e=>(Object(P["a"])("$incl",e,2,2),[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],1]])},{name:"++",fn:(e,t)=>e=>(Object(P["a"])("++",e,2,2),[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],1]])},{name:"$decl",fn:(e,t)=>e=>(Object(P["a"])("$decl",e,2,2),[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],-1]])},{name:"--",fn:(e,t)=>e=>(Object(P["a"])("--",e,2,2),[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],-1]])},{name:"$incln",fn:(e,t)=>e=>{if(Object(P["a"])("$incln",e,3,3),"number"!==typeof e[2])throw new Error("[SX] $incln: Invalid parameter: arg(1) is not number.");return[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],e[2]]]}},{name:"+=",fn:(e,t)=>e=>{if(Object(P["a"])("+=",e,3,3),"number"!==typeof e[2])throw new Error("[SX] +=: Invalid parameter: arg(1) is not number.");return[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],e[2]]]}},{name:"$decln",fn:(e,t)=>e=>{if(Object(P["a"])("$decln",e,3,3),"number"!==typeof e[2])throw new Error("[SX] $decln: Invalid parameter: arg(1) is not number.");return[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],-e[2]]]}},{name:"-=",fn:(e,t)=>e=>{if(Object(P["a"])("-=",e,3,3),"number"!==typeof e[2])throw new Error("[SX] -=: Invalid parameter: arg(1) is not number.");return[{symbol:"$set"},e[1],[{symbol:"$add"},e[1],-e[2]]]}}];var zt=Ht;const Yt=[];var Qt=Yt;function Zt(e){return e.funcs=(e.funcs||[]).concat(Jt),e.macros=(e.macros||[]).concat(zt),e.symbols=(e.symbols||[]).concat(Qt),e}class en{constructor(e){this.data=e}orderBy(e){let t;return t=Array.isArray(e)?(t,n)=>{for(const r of e)if("string"===typeof r){if(t[r]>n[r])return 1;if(t[r]<n[r])return-1}else{const e="desc"===r[1]?-1:1;if(t[r[0]]>n[r[0]])return 1*e;if(t[r[0]]<n[r[0]])return-1*e}return 0}:e,new en(this.data.slice(0).sort(t))}groupBy(e){let t;t=Array.isArray(e)?(t,n)=>{for(const r of e)if(t[r]!==n[r])return!1;return!0}:e;const n=[];let r=0,o=1;for(;o<this.data.length;o++)t(this.data[r],this.data[o],o,this.data)||(n.push(this.data.slice(r,o)),r=o);return n.push(this.data.slice(r,o)),new en(n)}groupEvery(e){if("number"===typeof e)return this.groupBy((t,n,r,o)=>r%e!==0);{const t=Object.assign({first:e.intermediate,last:e.intermediate},e),n=this.groupBy((e,n,r,o)=>t.single>=o.length?r%t.single!==0:r<=t.first?r%t.first!==0:(r-t.first)%t.intermediate!==0);return 1===n.data.length?t.single<n.data[0].length&&n.data.push([]):t.first<n.data[0].length&&n.data.unshift([]),n.data.length>1&&n.data[n.data.length-1].length>t.last&&n.data.push([]),n}}where(e){return new en(this.data.filter(e))}select(e){return e?this.data.map(e):this.data}}function tn(e){return new en(e)}const nn=(e,t)=>(...t)=>{Object(P["a"])("$range",t,2,3);const{car:n,cdr:r}=G(...t),o=Object(E["l"])(n)||0,a=Object(E["l"])(r)||0,s=t.length>2&&Object(E["l"])(t[2])||(o<=a?1:-1),l=Math.sign(a-o)+Math.sign(s)!==0?Math.floor(Math.abs(a-o)/Math.abs(s))+1:0;return e.evalCount+=l,Object(E["b"])(e,0),Array.from({length:l},(e,t)=>o+t*s)},rn=(e,t)=>(...e)=>{Object(P["a"])("$length",e,1,1);const t=R(...e);switch(typeof t){case"object":if(!("length"in t))break;case"string":return t.length}throw new Error("[SX] $length: Invalid argument type: object has no property 'length'.")},on=(rn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$trim",e,1,1);const t=R(...e);if("string"===typeof t)return t.trim();throw new Error("[SX] $trim: Invalid argument type: args[0] is not string.")}),an=(on(null,null),(e,t)=>(...e)=>{Object(P["a"])("$trimHead",e,1,1);const t=R(...e);if("string"===typeof t)return t.trimLeft();throw new Error("[SX] $trimHead: Invalid argument type: args[0] is not string.")}),sn=(an(null,null),(e,t)=>(...e)=>{Object(P["a"])("$trimTail",e,1,1);const t=R(...e);if("string"===typeof t)return t.trimRight();throw new Error("[SX] $trimTail: Invalid argument type: args[0] is not string.")}),ln=(sn(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$replaceAll",e,3,3),"string"===typeof e[0]&&"string"===typeof e[1]&&"string"===typeof e[2])return e[0].split(e[1]).join(e[2]);throw new Error("[SX] $replaceAll: Invalid argument type: args[0] or [1] or [2] is not string.")}),cn=(ln(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$split",e,2,2),"string"===typeof e[0]&&"string"===typeof e[1])return e[0].split(e[1]);throw new Error("[SX] $split: Invalid argument type: args[0] or [1] is not string.")}),un=(cn(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$join",e,1,2),Array.isArray(e[0]),e.length>1){if("string"===typeof e[1])return e[0].join(e[1]);throw new Error("[SX] $join: Invalid argument type: args[1] is not string.")}return e[0].join()}),fn=(un(null,null),(e,t)=>(...e)=>{Object(P["a"])("$concat",e,1);const t=R(...e);switch(typeof t){case"object":if(!("concat"in t))break;case"string":return t.concat(...e.slice(1))}throw new Error("[SX] $concat: Invalid argument type: object has no property 'concat'.")}),mn=(fn(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$slice",e,2,3),3===e.length&&("string"===typeof e[2]||Array.isArray(e[2])))return e[2].slice(Object(E["l"])(e[0]),Object(E["l"])(e[1]));if(2===e.length&&("string"===typeof e[1]||Array.isArray(e[1])))return e[1].slice(Object(E["l"])(e[0]));throw new Error(`[SX] $slice: Invalid argument type: args[${e.length-1}] is not string or array.`)}),bn=(mn(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$top",e,2,2),"string"===typeof e[1]||Array.isArray(e[1]))return e[1].slice(0,Object(E["l"])(e[0]));throw new Error("[SX] $top: Invalid argument type: args[1] is not string or array.")}),$n=(bn(null,null),(e,t)=>(...e)=>{if(Object(P["a"])("$tail",e,2,2),"string"===typeof e[1]||Array.isArray(e[1])){const t=-Object(E["l"])(e[0]);return e[1].slice(t>=0||Number.isNaN(t)?e[1].length:t)}throw new Error("[SX] $tail: Invalid argument type: args[1] is not string or array.")}),pn=($n(null,null),(e,t)=>(...e)=>(Object(P["a"])("$push",e,2,2),Array.isArray(e[0]),e[0].push(e[1]),e[0])),_n=(pn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$pop",e,1,1),Array.isArray(e[0]);{const t=e[0].pop();return t}}),dn=(_n(null,null),(e,t)=>(...e)=>{Object(P["a"])("$__at",e,2,2);const{car:t,cdr:n}=G(...e);return n[t]}),yn=(dn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$reverse",e,1,1);const t=R(...e);if(Array.isArray(t))return t.slice(0).reverse();throw new Error("[SX] $reverse: Invalid argument type: args[0] is not array.")}),gn=(yn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$reverse!",e,1,1);const t=R(...e);if(Array.isArray(t))return t.reverse();throw new Error("[SX] $reverse!: Invalid argument type: args[0] is not array.")}),jn=(gn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$find",e,2,2);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return t.find(n);throw new Error("[SX] $find: Invalid argument type: args[0] is not array.")}),On=(jn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$filter",e,2,2);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return t.filter(n);throw new Error("[SX] $filter: Invalid argument type: args[0] is not array.")}),hn=(On(null,null),(e,t)=>(...e)=>{Object(P["a"])("$map",e,2,2);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return t.map(n);throw new Error("[SX] $map: Invalid argument type: args[0] is not array.")}),vn=(hn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$reduce",e,2,3);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return e.length<3?t.reduce(n):t.reduce(n,e[2]);throw new Error("[SX] $reduce: Invalid argument type: args[0] is not array.")}),wn=(vn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$reduceFromTail",e,2,3);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return e.length<3?t.reduceRight(n):t.reduceRight(n,e[2]);throw new Error("[SX] $reduceFromTail: Invalid argument type: args[0] is not array.")}),Sn=(wn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$sort",e,2,2);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return t.slice(0).sort(n);throw new Error("[SX] $sort: Invalid argument type: args[0] is not array.")}),An=(Sn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$sort!",e,2,2);const{car:t,cdr:n}=G(...e);if(Array.isArray(t))return t.sort(n);throw new Error("[SX] $sort!: Invalid argument type: args[0] is not array.")}),En=(An(null,null),(e,t)=>(...e)=>{Object(P["a"])("$group-every",e,2,2);const{car:t,cdr:n}=G(...e);if(!Array.isArray(n))throw new Error("[SX] $group-every: Invalid argument type: args[1] is not array.");return tn(n).groupEvery(t).select()}),Nn=(En(null,null),(e,t)=>(...e)=>{Object(P["a"])("$group-by",e,2,2);const{car:t,cdr:n}=G(...e);if(!Array.isArray(n))throw new Error("[SX] $group-by: Invalid argument type: args[1] is not array.");return tn(n).groupBy(t).select()}),In=(Nn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$order-by",e,2,2);const{car:t,cdr:n}=G(...e);if(!Array.isArray(n))throw new Error("[SX] $order-by: Invalid argument type: args[1] is not array.");return tn(n).orderBy(t).select()}),kn=(In(null,null),(e,t)=>(...e)=>{Object(P["a"])("$where",e,2,2);const{car:t,cdr:n}=G(...e);if("function"!==typeof e[0])throw new Error("[SX] $where: Invalid argument type: args[0] is not function.");if(!Array.isArray(n))throw new Error("[SX] $where: Invalid argument type: args[1] is not array.");return tn(n).where(t).select()}),Tn=(kn(null,null),[{name:"$range",fn:nn},{name:"$length",fn:rn},{name:"$trim",fn:on},{name:"$trim-head",fn:an},{name:"$trim-tail",fn:sn},{name:"$replace-all",fn:ln},{name:"$split",fn:cn},{name:"$join",fn:un},{name:"$concat",fn:fn},{name:"$slice",fn:mn},{name:"$top",fn:bn},{name:"$tail",fn:$n},{name:"$push",fn:pn},{name:"$pop",fn:_n},{name:"$__at",fn:dn},{name:"$reverse",fn:yn},{name:"$reverse!",fn:gn},{name:"$find",fn:jn},{name:"$filter",fn:On},{name:"$map",fn:hn},{name:"$reduce",fn:vn},{name:"$reduce-from-head",fn:vn},{name:"$reduce-from-tail",fn:wn},{name:"$sort",fn:Sn},{name:"$sort!",fn:An},{name:"$group-every",fn:En},{name:"$group-by",fn:Nn},{name:"$order-by",fn:In},{name:"$where",fn:kn}]);var Xn=Tn;const xn=[{name:"$[",fn:(e,t)=>e=>{const t=Object(o["d"])(e[2],"]");if(!t)throw new Error("[SX] $repeat: Invalid syntax: missing ']' keyword.");return[{symbol:"$__at"},e[1],e[3]]}}];var Cn=xn;const Mn=[];var Pn=Mn;function Dn(e){return e.funcs=(e.funcs||[]).concat(Xn),e.macros=(e.macros||[]).concat(Cn),e.symbols=(e.symbols||[]).concat(Pn),e}const Ln=(e,t)=>(...t)=>{Object(P["a"])("$__letAsync",t,2,2);let n=t[1];return"object"===typeof n&&"function"===typeof n.then||(n=Promise.resolve(n)),n=n.then(n=>{try{return he(e,"")(t[0],n),n}catch(r){return Promise.reject(r)}}),n},qn=(Ln(null,null),(e,t)=>(...t)=>{Object(P["a"])("$__setAsync",t,2,2);let n=t[1];return"object"===typeof n&&"function"===typeof n.then||(n=Promise.resolve(n)),n=n.then(n=>{try{return ve(e,"")(t[0],n),n}catch(r){return Promise.reject(r)}}),n}),Un=(qn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$then",e,2,3);let t=e[0];if("object"===typeof t&&"function"===typeof t.then||(t=Promise.resolve(t)),"function"===typeof e[2])t=t.then(e[1],e[2]);else{if("function"!==typeof e[1])throw new Error("[SX] $then: Invalid argument(s): args[1] is not function.");t=t.then(e[1])}return t}),Rn=(Un(null,null),(e,t)=>(...e)=>{const t=e.slice(0);for(let n=0;n<t.length;n++)"object"===typeof t[n]&&"function"===typeof t[n].then||(t[n]=Promise.resolve(t[n]));return Promise.all(t)}),Fn=(Rn(null,null),(e,t)=>(...e)=>{const t=e.slice(0);for(let o=0;o<t.length;o++)"object"===typeof t[o]&&"function"===typeof t[o].then||(t[o]=Promise.resolve(t[o]));const n=e=>new Promise((t,n)=>e.then(n,t)),r=e=>n(Promise.all(e.map(n)));return r(t)}),Bn=(Fn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$resolvePipe",e,1);let t=e[0];"object"===typeof t&&"function"===typeof t.then||(t=Promise.resolve(t));const n=e.slice(1);for(let o=0;o<n.length;o++)if("function"!==typeof n[o]){const e=n[o];n[o]=()=>e}let r=t;for(const o of n)r=r.then(o);return r}),Wn=(Bn(null,null),(e,t)=>(...e)=>{Object(P["a"])("$resolveFork",e,1);let t=e[0];"object"===typeof t&&"function"===typeof t.then||(t=Promise.resolve(t));const n=e.slice(1);for(let s=0;s<n.length;s++)if("function"!==typeof n[s]){const e=n[s];n[s]=()=>e}const r=new Array(n.length),o=new Array(n.length),a=[];for(let s=0;s<n.length;s++)a.push(new Promise((e,t)=>{r[s]=r=>{let o=n[s](r);"object"===typeof o&&"function"===typeof o.then||(o=Promise.resolve(o)),o.then(t=>e(t)).catch(e=>t(e))},o[s]=t}));return t.then(e=>r.forEach(t=>t(e)),e=>o.forEach(t=>t(e))),a}),Kn=(Wn(null,null),[{name:"$__let-async",fn:Ln},{name:"$__set-async",fn:qn},{name:"$then",fn:Un},{name:"$resolve-all",fn:Rn},{name:"$resolve-any",fn:Fn},{name:"$resolve-pipe",fn:Bn},{name:"$resolve-fork",fn:Wn}]);var Vn=Kn;const Gn=[{name:"$let-async",fn:(e,t)=>t=>(Object(P["a"])("$let-async",t,3,3),[{symbol:"$__let-async"},Object(o["f"])(e,t[1]),t[2]])},{name:"$set-async",fn:(e,t)=>t=>(Object(P["a"])("$set-async",t,3,3),[{symbol:"$__set-async"},Object(o["f"])(e,t[1]),t[2]])}];var Jn=Gn;const Hn=[];var zn=Hn;function Yn(e){return e.funcs=(e.funcs||[]).concat(Vn),e.macros=(e.macros||[]).concat(Jn),e.symbols=(e.symbols||[]).concat(zn),e}const Qn=(()=>{let e=Object.assign({},s);return e.reservedNames=Object.assign({},e.reservedNames,{Template:"$concat"}),e=St(e),e=Zt(e),e=Dn(e),e=Yn(e),e.stripComments=!0,T(e)})(),Zn=Qn,er=Qn,tr=(()=>{let e=Object.assign({},s);return e.reservedNames=Object.assign({},e.reservedNames,{Template:"$concat"}),e=St(e),e=Zt(e),e=Dn(e),e=Yn(e),e.stripComments=!0,X(e)})(),nr=tr,rr=tr,or=(()=>{let e=Object.assign({},s);return e.reservedNames=Object.assign({},e.reservedNames,{Template:"$concat"}),e=St(e),e=Zt(e),e=Dn(e),e=Yn(e),e.stripComments=!0,e.returnMultipleRoot=!0,T(e)})(),ar=(()=>{let e=Object.assign({},s);return e.reservedNames=Object.assign({},e.reservedNames,{Template:"$concat"}),e=St(e),e=Zt(e),e=Dn(e),e=Yn(e),e.stripComments=!0,e.returnMultipleRoot=!0,X(e)})(),sr=(e,t)=>(...t)=>{Object(P["a"])("$__outputIf",t,2);const{car:n,cdr:r}=G(...t);let o=[];return Se(n)&&(2<t.length?(o.push({symbol:e.config.reservedNames.Template},...t.slice(1)),o=Object(E["b"])(e,o)):o=Object(E["b"])(e,r)),o},lr=(e,t)=>(...n)=>{Object(P["a"])("$__outputForOf",n,2);const r=R(...n),a=[];if(!Array.isArray(r))throw new Error("[SX] $__outputForOf: Invalid argument(s): args[0] is not array.");for(let s=0;s<r.length;s++){const l=r[s],c=Q(e,t)(!0,!0,[["$data",Object(o["f"])(e,l)],["$index",s],["$array",Object(o["f"])(e,r)],["$parent",Object(o["f"])(e,Object(E["e"])(e).scope)]],...n.slice(1));2<n.length&&Array.isArray(c)?a.push(...c):a.push(c)}return Object(E["b"])(e,[{symbol:e.config.reservedNames.Template}].concat(a.map(t=>[{symbol:e.config.reservedNames.quote},t])))},cr=(e,t)=>(...t)=>{const n={};for(const r of t){if(!(Array.isArray(r)&&0<r.length))throw new Error("[SX] $jsxProps: Invalid argument(s): args[?] is not array.");{const t=Object(o["d"])(r[0]),a=t?t.symbol:String(Object(E["b"])(e,r[0]));switch(a){case"style":if(1===r.length)n[a]="";else if(r.length>=2){const t={};for(const n of r.slice(1))if(Array.isArray(n)&&1<n.length){const r=String(Object(E["b"])(e,n[0]));Object(P["c"])("$jsxProps",t,r),t[r]=String(Object(E["b"])(e,n[1]))}else if("string"===typeof n)for(const e of n.split(";")){const n=/^\s*(\S+)\s*:\s*(.*?)\s*$/.exec(e);n&&(Object(P["c"])("$jsxProps",t,n[1]),t[n[1]]=n[2])}n[a]=t}break;case"class":case"styleClass":if(1===r.length)n[a]=[];else if(r.length>=2){let t=[];for(const n of r.slice(1))Array.isArray(n)?t=t.concat(n.map(t=>Object(E["b"])(e,t))):"string"===typeof n&&(t=t.concat(n.split(" ")));const o=[],s=e=>e.forEach(e=>null===e||void 0===e?void 0:Array.isArray(e)?s(e):o.push(String(e)));s(t),n[a]=o}break;case"className":if(1===r.length)n[a]="";else if(r.length>=2){let t="";for(const n of r.slice(1)){let r="";if(Array.isArray(n)){const t=[],o=n=>n.map(t=>Object(E["b"])(e,t)).forEach(e=>null===e||void 0===e?void 0:Array.isArray(e)?o(e):t.push(String(e)));o(n),r=t.join(" ")}else"string"===typeof n&&(r=n);0<t.length?t+=" "+r:t=r}n[a]=t}break;case"dangerouslySetInnerHTML":1===r.length?n[a]={__html:""}:r.length>=2?n[a]={__html:Object(E["b"])(e,r[1])}:n[a]={__html:Object(E["b"])(e,[{symbol:e.config.reservedNames.list}].concat(r.slice(1)))};break;case"setInnerText":1===r.length?n[a]={__text:""}:r.length>=2?n[a]={__text:Object(E["b"])(e,r[1])}:n[a]={__text:Object(E["b"])(e,[{symbol:e.config.reservedNames.list}].concat(r.slice(1)))};break;default:Object(P["c"])("$jsxProps",n,a),1===r.length?n[a]=!0:2===r.length?n[a]=Object(E["b"])(e,r[1]):n[a]=Object(E["b"])(e,[{symbol:e.config.reservedNames.list}].concat(r.slice(1)));break}}}return n};function ir(e,...t){let n=t,r={};if(0<t.length&&Array.isArray(t[0])){const a=Object(o["d"])(t[0][0],"@");a&&(r=cr(e,"")(...t[0].slice(1)),n=n.slice(1))}return{props:r,children:n}}const ur=(e,t)=>(...n)=>{const{props:r,children:o}=ir(e,...n);return e.config.jsx(t,r,...o)},fr=e=>(t,n)=>(...n)=>{const{props:r,children:o}=ir(t,...n);return t.config.jsx(e,r,...o)},mr=[{name:"$=__if",fn:sr},{name:"$=__for",fn:lr}];var br=mr;const $r=[{name:"@",fn:(e,t)=>t=>Object(o["f"])(e,t)},{name:"$=if",fn:(e,t)=>t=>[{symbol:"$=__if"},t[1],...t.slice(2).map(t=>Object(o["f"])(e,t))]},{name:"$=for",fn:(e,t)=>t=>[{symbol:"$=__for"},t[1],...t.slice(2).map(t=>Object(o["f"])(e,t))]}];var pr=$r;const _r=[];var dr=_r;function yr(e,t){e.funcs=(e.funcs||[]).concat(br),e.macros=(e.macros||[]).concat(pr),e.symbols=(e.symbols||[]).concat(dr);const n=Object.entries(t.components).map(e=>({name:e[0],fn:fr(e[1])}));return e.funcs=e.funcs.concat({name:e.reservedNames.Template,fn:fr(t.jsxFlagment)},...n),e.funcSymbolResolverFallback=ur,e.jsx=t.jsx,e.JsxFragment=t.jsxFlagment,e}function gr(e){let t=Object.assign({},s);return t=St(t),t=Zt(t),t=Dn(t),t=Yn(t),t=yr(t,e),t.stripComments=!0,T(t)}function jr(e){let t=Object.assign({},s);return t=St(t),t=Zt(t),t=Dn(t),t=Yn(t),t=yr(t,e),t.stripComments=!0,X(t)}function Or(e,t,n="text/lisp"){const r=document.querySelectorAll(`script[type="${n}"]`),o=[];for(let a=0;a<r.length;a++)o.push(r[a].innerHTML);return e=e.appendGlobals(t||{}),e(o.join("\n"))}const hr={core:gt,arithmetic:Jt,sequence:Xn,jsx:br,concurrent:Vn},vr={core:ht,arithmetic:zt,sequence:Cn,jsx:pr,concurrent:Jn},wr={core:wt,arithmetic:Qt,sequence:Pn,jsx:dr,concurrent:zn}}}]);
+//# sourceMappingURL=chunk-a06ef50c.1caef24f.js.map

dist/js/chunk-vendors.20f7f886.js

@@ -0,0 +1,8 @@
+(window["webpackJsonp"]=window["webpackJsonp"]||[]).push([["chunk-vendors"],{"24fb":function(t,e,n){"use strict";function r(t,e){var n=t[1]||"",r=t[3];if(!r)return n;if(e&&"function"===typeof btoa){var i=o(r),a=r.sources.map((function(t){return"/*# sourceURL=".concat(r.sourceRoot||"").concat(t," */")}));return[n].concat(a).concat([i]).join("\n")}return[n].join("\n")}function o(t){var e=btoa(unescape(encodeURIComponent(JSON.stringify(t)))),n="sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(e);return"/*# ".concat(n," */")}t.exports=function(t){var e=[];return e.toString=function(){return this.map((function(e){var n=r(e,t);return e[2]?"@media ".concat(e[2]," {").concat(n,"}"):n})).join("")},e.i=function(t,n,r){"string"===typeof t&&(t=[[null,t,""]]);var o={};if(r)for(var i=0;i<this.length;i++){var a=this[i][0];null!=a&&(o[a]=!0)}for(var s=0;s<t.length;s++){var c=[].concat(t[s]);r&&o[c[0]]||(n&&(c[2]?c[2]="".concat(n," and ").concat(c[2]):c[2]=n),e.push(c))}},e}},2877:function(t,e,n){"use strict";function r(t,e,n,r,o,i,a,s){var c,u="function"===typeof t?t.options:t;if(e&&(u.render=e,u.staticRenderFns=n,u._compiled=!0),r&&(u.functional=!0),i&&(u._scopeId="data-v-"+i),a?(c=function(t){t=t||this.$vnode&&this.$vnode.ssrContext||this.parent&&this.parent.$vnode&&this.parent.$vnode.ssrContext,t||"undefined"===typeof __VUE_SSR_CONTEXT__||(t=__VUE_SSR_CONTEXT__),o&&o.call(this,t),t&&t._registeredComponents&&t._registeredComponents.add(a)},u._ssrRegister=c):o&&(c=s?function(){o.call(this,(u.functional?this.parent:this).$root.$options.shadowRoot)}:o),c)if(u.functional){u._injectStyles=c;var l=u.render;u.render=function(t,e){return c.call(e),l(t,e)}}else{var f=u.beforeCreate;u.beforeCreate=f?[].concat(f,c):[c]}return{exports:t,options:u}}n.d(e,"a",(function(){return r}))},"2b0e":function(t,e,n){"use strict";(function(t){n.d(e,"a",(function(){return Qr}));
+/*!
+ * Vue.js v2.7.16
+ * (c) 2014-2023 Evan You
+ * Released under the MIT License.
+ */
+var r=Object.freeze({}),o=Array.isArray;function i(t){return void 0===t||null===t}function a(t){return void 0!==t&&null!==t}function s(t){return!0===t}function c(t){return!1===t}function u(t){return"string"===typeof t||"number"===typeof t||"symbol"===typeof t||"boolean"===typeof t}function l(t){return"function"===typeof t}function f(t){return null!==t&&"object"===typeof t}var d=Object.prototype.toString;function p(t){return"[object Object]"===d.call(t)}function v(t){return"[object RegExp]"===d.call(t)}function h(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function m(t){return a(t)&&"function"===typeof t.then&&"function"===typeof t.catch}function _(t){return null==t?"":Array.isArray(t)||p(t)&&t.toString===d?JSON.stringify(t,y,2):String(t)}function y(t,e){return e&&e.__v_isRef?e.value:e}function g(t){var e=parseFloat(t);return isNaN(e)?t:e}function b(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}b("slot,component",!0);var w=b("key,ref,slot,slot-scope,is");function C(t,e){var n=t.length;if(n){if(e===t[n-1])return void(t.length=n-1);var r=t.indexOf(e);if(r>-1)return t.splice(r,1)}}var $=Object.prototype.hasOwnProperty;function x(t,e){return $.call(t,e)}function k(t){var e=Object.create(null);return function(n){var r=e[n];return r||(e[n]=t(n))}}var O=/-(\w)/g,S=k((function(t){return t.replace(O,(function(t,e){return e?e.toUpperCase():""}))})),j=k((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),T=/\B([A-Z])/g,A=k((function(t){return t.replace(T,"-$1").toLowerCase()}));function E(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n}function I(t,e){return t.bind(e)}var P=Function.prototype.bind?I:E;function N(t,e){e=e||0;var n=t.length-e,r=new Array(n);while(n--)r[n]=t[n+e];return r}function D(t,e){for(var n in e)t[n]=e[n];return t}function M(t){for(var e={},n=0;n<t.length;n++)t[n]&&D(e,t[n]);return e}function L(t,e,n){}var F=function(t,e,n){return!1},R=function(t){return t};function U(t,e){if(t===e)return!0;var n=f(t),r=f(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),i=Array.isArray(e);if(o&&i)return t.length===e.length&&t.every((function(t,n){return U(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||i)return!1;var a=Object.keys(t),s=Object.keys(e);return a.length===s.length&&a.every((function(n){return U(t[n],e[n])}))}catch(c){return!1}}function B(t,e){for(var n=0;n<t.length;n++)if(U(t[n],e))return n;return-1}function V(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}function H(t,e){return t===e?0===t&&1/t!==1/e:t===t||e===e}var z="data-server-rendered",W=["component","directive","filter"],q=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch","renderTracked","renderTriggered"],K={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:F,isReservedAttr:F,isUnknownElement:F,getTagNamespace:L,parsePlatformTagName:R,mustUseProp:F,async:!0,_lifecycleHooks:q},G=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function J(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function X(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var Z=new RegExp("[^".concat(G.source,".$_\\d]"));function Q(t){if(!Z.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}var Y="__proto__"in{},tt="undefined"!==typeof window,et=tt&&window.navigator.userAgent.toLowerCase(),nt=et&&/msie|trident/.test(et),rt=et&&et.indexOf("msie 9.0")>0,ot=et&&et.indexOf("edge/")>0;et&&et.indexOf("android");var it=et&&/iphone|ipad|ipod|ios/.test(et);et&&/chrome\/\d+/.test(et),et&&/phantomjs/.test(et);var at,st=et&&et.match(/firefox\/(\d+)/),ct={}.watch,ut=!1;if(tt)try{var lt={};Object.defineProperty(lt,"passive",{get:function(){ut=!0}}),window.addEventListener("test-passive",null,lt)}catch(Ya){}var ft=function(){return void 0===at&&(at=!tt&&"undefined"!==typeof t&&(t["process"]&&"server"===t["process"].env.VUE_ENV)),at},dt=tt&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function pt(t){return"function"===typeof t&&/native code/.test(t.toString())}var vt,ht="undefined"!==typeof Symbol&&pt(Symbol)&&"undefined"!==typeof Reflect&&pt(Reflect.ownKeys);vt="undefined"!==typeof Set&&pt(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var mt=null;function _t(t){void 0===t&&(t=null),t||mt&&mt._scope.off(),mt=t,t&&t._scope.on()}var yt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),gt=function(t){void 0===t&&(t="");var e=new yt;return e.text=t,e.isComment=!0,e};function bt(t){return new yt(void 0,void 0,void 0,String(t))}function wt(t){var e=new yt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}"function"===typeof SuppressedError&&SuppressedError;var Ct=0,$t=[],xt=function(){for(var t=0;t<$t.length;t++){var e=$t[t];e.subs=e.subs.filter((function(t){return t})),e._pending=!1}$t.length=0},kt=function(){function t(){this._pending=!1,this.id=Ct++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){this.subs[this.subs.indexOf(t)]=null,this._pending||(this._pending=!0,$t.push(this))},t.prototype.depend=function(e){t.target&&t.target.addDep(this)},t.prototype.notify=function(t){var e=this.subs.filter((function(t){return t}));for(var n=0,r=e.length;n<r;n++){var o=e[n];0,o.update()}},t}();kt.target=null;var Ot=[];function St(t){Ot.push(t),kt.target=t}function jt(){Ot.pop(),kt.target=Ot[Ot.length-1]}var Tt=Array.prototype,At=Object.create(Tt),Et=["push","pop","shift","unshift","splice","sort","reverse"];Et.forEach((function(t){var e=Tt[t];X(At,t,(function(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2);break}return o&&a.observeArray(o),a.dep.notify(),i}))}));var It=Object.getOwnPropertyNames(At),Pt={},Nt=!0;function Dt(t){Nt=t}var Mt={notify:L,depend:L,addSub:L,removeSub:L},Lt=function(){function t(t,e,n){if(void 0===e&&(e=!1),void 0===n&&(n=!1),this.value=t,this.shallow=e,this.mock=n,this.dep=n?Mt:new kt,this.vmCount=0,X(t,"__ob__",this),o(t)){if(!n)if(Y)t.__proto__=At;else for(var r=0,i=It.length;r<i;r++){var a=It[r];X(t,a,At[a])}e||this.observeArray(t)}else{var s=Object.keys(t);for(r=0;r<s.length;r++){a=s[r];Rt(t,a,Pt,void 0,e,n)}}}return t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ft(t[e],!1,this.mock)},t}();function Ft(t,e,n){return t&&x(t,"__ob__")&&t.__ob__ instanceof Lt?t.__ob__:!Nt||!n&&ft()||!o(t)&&!p(t)||!Object.isExtensible(t)||t.__v_skip||qt(t)||t instanceof yt?void 0:new Lt(t,e,n)}function Rt(t,e,n,r,i,a,s){void 0===s&&(s=!1);var c=new kt,u=Object.getOwnPropertyDescriptor(t,e);if(!u||!1!==u.configurable){var l=u&&u.get,f=u&&u.set;l&&!f||n!==Pt&&2!==arguments.length||(n=t[e]);var d=i?n&&n.__ob__:Ft(n,!1,a);return Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=l?l.call(t):n;return kt.target&&(c.depend(),d&&(d.dep.depend(),o(e)&&Vt(e))),qt(e)&&!i?e.value:e},set:function(e){var r=l?l.call(t):n;if(H(r,e)){if(f)f.call(t,e);else{if(l)return;if(!i&&qt(r)&&!qt(e))return void(r.value=e);n=e}d=i?e&&e.__ob__:Ft(e,!1,a),c.notify()}}}),c}}function Ut(t,e,n){if(!Wt(t)){var r=t.__ob__;return o(t)&&h(e)?(t.length=Math.max(t.length,e),t.splice(e,1,n),r&&!r.shallow&&r.mock&&Ft(n,!1,!0),n):e in t&&!(e in Object.prototype)?(t[e]=n,n):t._isVue||r&&r.vmCount?n:r?(Rt(r.value,e,n,void 0,r.shallow,r.mock),r.dep.notify(),n):(t[e]=n,n)}}function Bt(t,e){if(o(t)&&h(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||Wt(t)||x(t,e)&&(delete t[e],n&&n.dep.notify())}}function Vt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),o(e)&&Vt(e)}function Ht(t){return zt(t,!0),X(t,"__v_isShallow",!0),t}function zt(t,e){if(!Wt(t)){Ft(t,e,ft());0}}function Wt(t){return!(!t||!t.__v_isReadonly)}function qt(t){return!(!t||!0!==t.__v_isRef)}function Kt(t,e,n){Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:function(){var t=e[n];if(qt(t))return t.value;var r=t&&t.__ob__;return r&&r.dep.depend(),t},set:function(t){var r=e[n];qt(r)&&!qt(t)?r.value=t:e[n]=t}})}var Gt="watcher";"".concat(Gt," callback"),"".concat(Gt," getter"),"".concat(Gt," cleanup");var Jt;var Xt=function(){function t(t){void 0===t&&(t=!1),this.detached=t,this.active=!0,this.effects=[],this.cleanups=[],this.parent=Jt,!t&&Jt&&(this.index=(Jt.scopes||(Jt.scopes=[])).push(this)-1)}return t.prototype.run=function(t){if(this.active){var e=Jt;try{return Jt=this,t()}finally{Jt=e}}else 0},t.prototype.on=function(){Jt=this},t.prototype.off=function(){Jt=this.parent},t.prototype.stop=function(t){if(this.active){var e=void 0,n=void 0;for(e=0,n=this.effects.length;e<n;e++)this.effects[e].teardown();for(e=0,n=this.cleanups.length;e<n;e++)this.cleanups[e]();if(this.scopes)for(e=0,n=this.scopes.length;e<n;e++)this.scopes[e].stop(!0);if(!this.detached&&this.parent&&!t){var r=this.parent.scopes.pop();r&&r!==this&&(this.parent.scopes[this.index]=r,r.index=this.index)}this.parent=void 0,this.active=!1}},t}();function Zt(t,e){void 0===e&&(e=Jt),e&&e.active&&e.effects.push(t)}function Qt(){return Jt}function Yt(t){var e=t._provided,n=t.$parent&&t.$parent._provided;return n===e?t._provided=Object.create(n):e}var te=k((function(t){var e="&"===t.charAt(0);t=e?t.slice(1):t;var n="~"===t.charAt(0);t=n?t.slice(1):t;var r="!"===t.charAt(0);return t=r?t.slice(1):t,{name:t,once:n,capture:r,passive:e}}));function ee(t,e){function n(){var t=n.fns;if(!o(t))return Ze(t,null,arguments,e,"v-on handler");for(var r=t.slice(),i=0;i<r.length;i++)Ze(r[i],null,arguments,e,"v-on handler")}return n.fns=t,n}function ne(t,e,n,r,o,a){var c,u,l,f;for(c in t)u=t[c],l=e[c],f=te(c),i(u)||(i(l)?(i(u.fns)&&(u=t[c]=ee(u,a)),s(f.once)&&(u=t[c]=o(f.name,u,f.capture)),n(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in e)i(t[c])&&(f=te(c),r(f.name,e[c],f.capture))}function re(t,e,n){var r;t instanceof yt&&(t=t.data.hook||(t.data.hook={}));var o=t[e];function c(){n.apply(this,arguments),C(r.fns,c)}i(o)?r=ee([c]):a(o.fns)&&s(o.merged)?(r=o,r.fns.push(c)):r=ee([o,c]),r.merged=!0,t[e]=r}function oe(t,e,n){var r=e.options.props;if(!i(r)){var o={},s=t.attrs,c=t.props;if(a(s)||a(c))for(var u in r){var l=A(u);ie(o,c,u,l,!0)||ie(o,s,u,l,!1)}return o}}function ie(t,e,n,r,o){if(a(e)){if(x(e,n))return t[n]=e[n],o||delete e[n],!0;if(x(e,r))return t[n]=e[r],o||delete e[r],!0}return!1}function ae(t){for(var e=0;e<t.length;e++)if(o(t[e]))return Array.prototype.concat.apply([],t);return t}function se(t){return u(t)?[bt(t)]:o(t)?ue(t):void 0}function ce(t){return a(t)&&a(t.text)&&c(t.isComment)}function ue(t,e){var n,r,c,l,f=[];for(n=0;n<t.length;n++)r=t[n],i(r)||"boolean"===typeof r||(c=f.length-1,l=f[c],o(r)?r.length>0&&(r=ue(r,"".concat(e||"","_").concat(n)),ce(r[0])&&ce(l)&&(f[c]=bt(l.text+r[0].text),r.shift()),f.push.apply(f,r)):u(r)?ce(l)?f[c]=bt(l.text+r):""!==r&&f.push(bt(r)):ce(r)&&ce(l)?f[c]=bt(l.text+r.text):(s(t._isVList)&&a(r.tag)&&i(r.key)&&a(e)&&(r.key="__vlist".concat(e,"_").concat(n,"__")),f.push(r)));return f}function le(t,e){var n,r,i,s,c=null;if(o(t)||"string"===typeof t)for(c=new Array(t.length),n=0,r=t.length;n<r;n++)c[n]=e(t[n],n);else if("number"===typeof t)for(c=new Array(t),n=0;n<t;n++)c[n]=e(n+1,n);else if(f(t))if(ht&&t[Symbol.iterator]){c=[];var u=t[Symbol.iterator](),l=u.next();while(!l.done)c.push(e(l.value,c.length)),l=u.next()}else for(i=Object.keys(t),c=new Array(i.length),n=0,r=i.length;n<r;n++)s=i[n],c[n]=e(t[s],s,n);return a(c)||(c=[]),c._isVList=!0,c}function fe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=D(D({},r),n)),o=i(n)||(l(e)?e():e)):o=this.$slots[t]||(l(e)?e():e);var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function de(t){return kr(this.$options,"filters",t,!0)||R}function pe(t,e){return o(t)?-1===t.indexOf(e):t!==e}function ve(t,e,n,r,o){var i=K.keyCodes[e]||n;return o&&r&&!K.keyCodes[e]?pe(o,r):i?pe(i,t):r?A(r)!==e:void 0===t}function he(t,e,n,r,i){if(n)if(f(n)){o(n)&&(n=M(n));var a=void 0,s=function(o){if("class"===o||"style"===o||w(o))a=t;else{var s=t.attrs&&t.attrs.type;a=r||K.mustUseProp(e,s,o)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=S(o),u=A(o);if(!(c in a)&&!(u in a)&&(a[o]=n[o],i)){var l=t.on||(t.on={});l["update:".concat(o)]=function(t){n[o]=t}}};for(var c in n)s(c)}else;return t}function me(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,this._c,this),ye(r,"__static__".concat(t),!1)),r}function _e(t,e,n){return ye(t,"__once__".concat(e).concat(n?"_".concat(n):""),!0),t}function ye(t,e,n){if(o(t))for(var r=0;r<t.length;r++)t[r]&&"string"!==typeof t[r]&&ge(t[r],"".concat(e,"_").concat(r),n);else ge(t,e,n)}function ge(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function be(t,e){if(e)if(p(e)){var n=t.on=t.on?D({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var i=0;i<t.length;i++){var a=t[i];o(a)?we(a,e,n):a&&(a.proxy&&(a.fn.proxy=!0),e[a.key]=a.fn)}return r&&(e.$key=r),e}function Ce(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"===typeof r&&r&&(t[e[n]]=e[n+1])}return t}function $e(t,e){return"string"===typeof t?e+t:t}function xe(t){t._o=_e,t._n=g,t._s=_,t._l=le,t._t=fe,t._q=U,t._i=B,t._m=me,t._f=de,t._k=ve,t._b=he,t._v=bt,t._e=gt,t._u=we,t._g=be,t._d=Ce,t._p=$e}function ke(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(Oe)&&delete n[u];return n}function Oe(t){return t.isComment&&!t.asyncFactory||" "===t.text}function Se(t){return t.isComment&&t.asyncFactory}function je(t,e,n,o){var i,a=Object.keys(n).length>0,s=e?!!e.$stable:!a,c=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(s&&o&&o!==r&&c===o.$key&&!a&&!o.$hasNormal)return o;for(var u in i={},e)e[u]&&"$"!==u[0]&&(i[u]=Te(t,n,u,e[u]))}else i={};for(var l in n)l in i||(i[l]=Ae(n,l));return e&&Object.isExtensible(e)&&(e._normalized=i),X(i,"$stable",s),X(i,"$key",c),X(i,"$hasNormal",a),i}function Te(t,e,n,r){var i=function(){var e=mt;_t(t);var n=arguments.length?r.apply(null,arguments):r({});n=n&&"object"===typeof n&&!o(n)?[n]:se(n);var i=n&&n[0];return _t(e),n&&(!i||1===n.length&&i.isComment&&!Se(i))?void 0:n};return r.proxy&&Object.defineProperty(e,n,{get:i,enumerable:!0,configurable:!0}),i}function Ae(t,e){return function(){return t[e]}}function Ee(t){var e=t.$options,n=e.setup;if(n){var r=t._setupContext=Ie(t);_t(t),St();var o=Ze(n,null,[t._props||Ht({}),r],t,"setup");if(jt(),_t(),l(o))e.render=o;else if(f(o))if(t._setupState=o,o.__sfc){var i=t._setupProxy={};for(var a in o)"__sfc"!==a&&Kt(i,o,a)}else for(var a in o)J(a)||Kt(t,o,a);else 0}}function Ie(t){return{get attrs(){if(!t._attrsProxy){var e=t._attrsProxy={};X(e,"_v_attr_proxy",!0),Pe(e,t.$attrs,r,t,"$attrs")}return t._attrsProxy},get listeners(){if(!t._listenersProxy){var e=t._listenersProxy={};Pe(e,t.$listeners,r,t,"$listeners")}return t._listenersProxy},get slots(){return De(t)},emit:P(t.$emit,t),expose:function(e){e&&Object.keys(e).forEach((function(n){return Kt(t,e,n)}))}}}function Pe(t,e,n,r,o){var i=!1;for(var a in e)a in t?e[a]!==n[a]&&(i=!0):(i=!0,Ne(t,a,r,o));for(var a in t)a in e||(i=!0,delete t[a]);return i}function Ne(t,e,n,r){Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){return n[r][e]}})}function De(t){return t._slotsProxy||Me(t._slotsProxy={},t.$scopedSlots),t._slotsProxy}function Me(t,e){for(var n in e)t[n]=e[n];for(var n in t)n in e||delete t[n]}function Le(t){t._vnode=null,t._staticTrees=null;var e=t.$options,n=t.$vnode=e._parentVnode,o=n&&n.context;t.$slots=ke(e._renderChildren,o),t.$scopedSlots=n?je(t.$parent,n.data.scopedSlots,t.$slots):r,t._c=function(e,n,r,o){return qe(t,e,n,r,o,!1)},t.$createElement=function(e,n,r,o){return qe(t,e,n,r,o,!0)};var i=n&&n.data;Rt(t,"$attrs",i&&i.attrs||r,null,!0),Rt(t,"$listeners",e._parentListeners||r,null,!0)}var Fe=null;function Re(t){xe(t.prototype),t.prototype.$nextTick=function(t){return ln(t,this)},t.prototype._render=function(){var t=this,e=t.$options,n=e.render,r=e._parentVnode;r&&t._isMounted&&(t.$scopedSlots=je(t.$parent,r.data.scopedSlots,t.$slots,t.$scopedSlots),t._slotsProxy&&Me(t._slotsProxy,t.$scopedSlots)),t.$vnode=r;var i,a=mt,s=Fe;try{_t(t),Fe=t,i=n.call(t._renderProxy,t.$createElement)}catch(Ya){Xe(Ya,t,"render"),i=t._vnode}finally{Fe=s,_t(a)}return o(i)&&1===i.length&&(i=i[0]),i instanceof yt||(i=gt()),i.parent=r,i}}function Ue(t,e){return(t.__esModule||ht&&"Module"===t[Symbol.toStringTag])&&(t=t.default),f(t)?e.extend(t):t}function Be(t,e,n,r,o){var i=gt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}function Ve(t,e){if(s(t.error)&&a(t.errorComp))return t.errorComp;if(a(t.resolved))return t.resolved;var n=Fe;if(n&&a(t.owners)&&-1===t.owners.indexOf(n)&&t.owners.push(n),s(t.loading)&&a(t.loadingComp))return t.loadingComp;if(n&&!a(t.owners)){var r=t.owners=[n],o=!0,c=null,u=null;n.$on("hook:destroyed",(function(){return C(r,n)}));var l=function(t){for(var e=0,n=r.length;e<n;e++)r[e].$forceUpdate();t&&(r.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=V((function(n){t.resolved=Ue(n,e),o?r.length=0:l(!0)})),p=V((function(e){a(t.errorComp)&&(t.error=!0,l(!0))})),v=t(d,p);return f(v)&&(m(v)?i(t.resolved)&&v.then(d,p):m(v.component)&&(v.component.then(d,p),a(v.error)&&(t.errorComp=Ue(v.error,e)),a(v.loading)&&(t.loadingComp=Ue(v.loading,e),0===v.delay?t.loading=!0:c=setTimeout((function(){c=null,i(t.resolved)&&i(t.error)&&(t.loading=!0,l(!1))}),v.delay||200)),a(v.timeout)&&(u=setTimeout((function(){u=null,i(t.resolved)&&p(null)}),v.timeout)))),o=!1,t.loading?t.loadingComp:t.resolved}}function He(t){if(o(t))for(var e=0;e<t.length;e++){var n=t[e];if(a(n)&&(a(n.componentOptions)||Se(n)))return n}}var ze=1,We=2;function qe(t,e,n,r,i,a){return(o(n)||u(n))&&(i=r,r=n,n=void 0),s(a)&&(i=We),Ke(t,e,n,r,i)}function Ke(t,e,n,r,i){if(a(n)&&a(n.__ob__))return gt();if(a(n)&&a(n.is)&&(e=n.is),!e)return gt();var s,c;if(o(r)&&l(r[0])&&(n=n||{},n.scopedSlots={default:r[0]},r.length=0),i===We?r=se(r):i===ze&&(r=ae(r)),"string"===typeof e){var u=void 0;c=t.$vnode&&t.$vnode.ns||K.getTagNamespace(e),s=K.isReservedTag(e)?new yt(K.parsePlatformTagName(e),n,r,void 0,void 0,t):n&&n.pre||!a(u=kr(t.$options,"components",e))?new yt(e,n,r,void 0,void 0,t):cr(u,n,t,r,e)}else s=cr(e,n,t,r);return o(s)?s:a(s)?(a(c)&&Ge(s,c),a(n)&&Je(n),s):gt()}function Ge(t,e,n){if(t.ns=e,"foreignObject"===t.tag&&(e=void 0,n=!0),a(t.children))for(var r=0,o=t.children.length;r<o;r++){var c=t.children[r];a(c.tag)&&(i(c.ns)||s(n)&&"svg"!==c.tag)&&Ge(c,e,n)}}function Je(t){f(t.style)&&hn(t.style),f(t.class)&&hn(t.class)}function Xe(t,e,n){St();try{if(e){var r=e;while(r=r.$parent){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{var a=!1===o[i].call(r,t,e,n);if(a)return}catch(Ya){Qe(Ya,r,"errorCaptured hook")}}}Qe(t,e,n)}finally{jt()}}function Ze(t,e,n,r,o){var i;try{i=n?t.apply(e,n):t.call(e),i&&!i._isVue&&m(i)&&!i._handled&&(i.catch((function(t){return Xe(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(Ya){Xe(Ya,r,o)}return i}function Qe(t,e,n){if(K.errorHandler)try{return K.errorHandler.call(null,t,e,n)}catch(Ya){Ya!==t&&Ye(Ya,null,"config.errorHandler")}Ye(t,e,n)}function Ye(t,e,n){if(!tt||"undefined"===typeof console)throw t;console.error(t)}var tn,en=!1,nn=[],rn=!1;function on(){rn=!1;var t=nn.slice(0);nn.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!==typeof Promise&&pt(Promise)){var an=Promise.resolve();tn=function(){an.then(on),it&&setTimeout(L)},en=!0}else if(nt||"undefined"===typeof MutationObserver||!pt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())tn="undefined"!==typeof setImmediate&&pt(setImmediate)?function(){setImmediate(on)}:function(){setTimeout(on,0)};else{var sn=1,cn=new MutationObserver(on),un=document.createTextNode(String(sn));cn.observe(un,{characterData:!0}),tn=function(){sn=(sn+1)%2,un.data=String(sn)},en=!0}function ln(t,e){var n;if(nn.push((function(){if(t)try{t.call(e)}catch(Ya){Xe(Ya,e,"nextTick")}else n&&n(e)})),rn||(rn=!0,tn()),!t&&"undefined"!==typeof Promise)return new Promise((function(t){n=t}))}function fn(t){return function(e,n){if(void 0===n&&(n=mt),n)return dn(n,t,e)}}function dn(t,e,n){var r=t.$options;r[e]=_r(r[e],n)}fn("beforeMount"),fn("mounted"),fn("beforeUpdate"),fn("updated"),fn("beforeDestroy"),fn("destroyed"),fn("activated"),fn("deactivated"),fn("serverPrefetch"),fn("renderTracked"),fn("renderTriggered"),fn("errorCaptured");var pn="2.7.16";var vn=new vt;function hn(t){return mn(t,vn),vn.clear(),t}function mn(t,e){var n,r,i=o(t);if(!(!i&&!f(t)||t.__v_skip||Object.isFrozen(t)||t instanceof yt)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(i){n=t.length;while(n--)mn(t[n],e)}else if(qt(t))mn(t.value,e);else{r=Object.keys(t),n=r.length;while(n--)mn(t[r[n]],e)}}}var _n,yn=0,gn=function(){function t(t,e,n,r,o){Zt(this,Jt&&!Jt._vm?Jt:t?t._scope:void 0),(this.vm=t)&&o&&(t._watcher=this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++yn,this.active=!0,this.post=!1,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new vt,this.newDepIds=new vt,this.expression="",l(e)?this.getter=e:(this.getter=Q(e),this.getter||(this.getter=L)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;St(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(Ya){if(!this.user)throw Ya;Xe(Ya,e,'getter for watcher "'.concat(this.expression,'"'))}finally{this.deep&&hn(t),jt(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){var t=this.deps.length;while(t--){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():Zn(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||f(t)||this.deep){var e=this.value;if(this.value=t,this.user){var n='callback for watcher "'.concat(this.expression,'"');Ze(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){var t=this.deps.length;while(t--)this.deps[t].depend()},t.prototype.teardown=function(){if(this.vm&&!this.vm._isBeingDestroyed&&C(this.vm._scope.effects,this),this.active){var t=this.deps.length;while(t--)this.deps[t].removeSub(this);this.active=!1,this.onStop&&this.onStop()}},t}();function bn(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&xn(t,e)}function wn(t,e){_n.$on(t,e)}function Cn(t,e){_n.$off(t,e)}function $n(t,e){var n=_n;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function xn(t,e,n){_n=t,ne(e,n||{},wn,Cn,$n,t),_n=void 0}function kn(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(o(t))for(var i=0,a=t.length;i<a;i++)r.$on(t[i],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(o(t)){for(var r=0,i=t.length;r<i;r++)n.$off(t[r],e);return n}var a,s=n._events[t];if(!s)return n;if(!e)return n._events[t]=null,n;var c=s.length;while(c--)if(a=s[c],a===e||a.fn===e){s.splice(c,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?N(n):n;for(var r=N(arguments,1),o='event handler for "'.concat(t,'"'),i=0,a=n.length;i<a;i++)Ze(n[i],e,r,e,o)}return e}}var On=null;function Sn(t){var e=On;return On=t,function(){On=e}}function jn(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){while(n.$options.abstract&&n.$parent)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._provided=n?n._provided:Object.create(null),t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}function Tn(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Sn(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n);var a=n;while(a&&a.$vnode&&a.$parent&&a.$vnode===a.$parent._vnode)a.$parent.$el=a.$el,a=a.$parent},t.prototype.$forceUpdate=function(){var t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Dn(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||C(e.$children,t),t._scope.stop(),t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Dn(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}function An(t,e,n){var r;t.$el=e,t.$options.render||(t.$options.render=gt),Dn(t,"beforeMount"),r=function(){t._update(t._render(),n)};var o={before:function(){t._isMounted&&!t._isDestroyed&&Dn(t,"beforeUpdate")}};new gn(t,r,L,o,!0),n=!1;var i=t._preWatchers;if(i)for(var a=0;a<i.length;a++)i[a].run();return null==t.$vnode&&(t._isMounted=!0,Dn(t,"mounted")),t}function En(t,e,n,o,i){var a=o.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==r&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key||!a&&t.$scopedSlots.$key),u=!!(i||t.$options._renderChildren||c),l=t.$vnode;t.$options._parentVnode=o,t.$vnode=o,t._vnode&&(t._vnode.parent=o),t.$options._renderChildren=i;var f=o.data.attrs||r;t._attrsProxy&&Pe(t._attrsProxy,f,l.data&&l.data.attrs||r,t,"$attrs")&&(u=!0),t.$attrs=f,n=n||r;var d=t.$options._parentListeners;if(t._listenersProxy&&Pe(t._listenersProxy,n,d||r,t,"$listeners"),t.$listeners=t.$options._parentListeners=n,xn(t,n,d),e&&t.$options.props){Dt(!1);for(var p=t._props,v=t.$options._propKeys||[],h=0;h<v.length;h++){var m=v[h],_=t.$options.props;p[m]=Or(m,_,e,t)}Dt(!0),t.$options.propsData=e}u&&(t.$slots=ke(i,o.context),t.$forceUpdate())}function In(t){while(t&&(t=t.$parent))if(t._inactive)return!0;return!1}function Pn(t,e){if(e){if(t._directInactive=!1,In(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Pn(t.$children[n]);Dn(t,"activated")}}function Nn(t,e){if((!e||(t._directInactive=!0,!In(t)))&&!t._inactive){t._inactive=!0;for(var n=0;n<t.$children.length;n++)Nn(t.$children[n]);Dn(t,"deactivated")}}function Dn(t,e,n,r){void 0===r&&(r=!0),St();var o=mt,i=Qt();r&&_t(t);var a=t.$options[e],s="".concat(e," hook");if(a)for(var c=0,u=a.length;c<u;c++)Ze(a[c],t,n||null,t,s);t._hasHookEvent&&t.$emit("hook:"+e),r&&(_t(o),i&&i.on()),jt()}var Mn=[],Ln=[],Fn={},Rn=!1,Un=!1,Bn=0;function Vn(){Bn=Mn.length=Ln.length=0,Fn={},Rn=Un=!1}var Hn=0,zn=Date.now;if(tt&&!nt){var Wn=window.performance;Wn&&"function"===typeof Wn.now&&zn()>document.createEvent("Event").timeStamp&&(zn=function(){return Wn.now()})}var qn=function(t,e){if(t.post){if(!e.post)return 1}else if(e.post)return-1;return t.id-e.id};function Kn(){var t,e;for(Hn=zn(),Un=!0,Mn.sort(qn),Bn=0;Bn<Mn.length;Bn++)t=Mn[Bn],t.before&&t.before(),e=t.id,Fn[e]=null,t.run();var n=Ln.slice(),r=Mn.slice();Vn(),Xn(n),Gn(r),xt(),dt&&K.devtools&&dt.emit("flush")}function Gn(t){var e=t.length;while(e--){var n=t[e],r=n.vm;r&&r._watcher===n&&r._isMounted&&!r._isDestroyed&&Dn(r,"updated")}}function Jn(t){t._inactive=!1,Ln.push(t)}function Xn(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Pn(t[e],!0)}function Zn(t){var e=t.id;if(null==Fn[e]&&(t!==kt.target||!t.noRecurse)){if(Fn[e]=!0,Un){var n=Mn.length-1;while(n>Bn&&Mn[n].id>t.id)n--;Mn.splice(n+1,0,t)}else Mn.push(t);Rn||(Rn=!0,ln(Kn))}}function Qn(t){var e=t.$options.provide;if(e){var n=l(e)?e.call(t):e;if(!f(n))return;for(var r=Yt(t),o=ht?Reflect.ownKeys(n):Object.keys(n),i=0;i<o.length;i++){var a=o[i];Object.defineProperty(r,a,Object.getOwnPropertyDescriptor(n,a))}}}function Yn(t){var e=tr(t.$options.inject,t);e&&(Dt(!1),Object.keys(e).forEach((function(n){Rt(t,n,e[n])})),Dt(!0))}function tr(t,e){if(t){for(var n=Object.create(null),r=ht?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){var a=t[i].from;if(a in e._provided)n[i]=e._provided[a];else if("default"in t[i]){var s=t[i].default;n[i]=l(s)?s.call(e):s}else 0}}return n}}function er(t,e,n,i,a){var c,u=this,l=a.options;x(i,"_uid")?(c=Object.create(i),c._original=i):(c=i,i=i._original);var f=s(l._compiled),d=!f;this.data=t,this.props=e,this.children=n,this.parent=i,this.listeners=t.on||r,this.injections=tr(l.inject,i),this.slots=function(){return u.$slots||je(i,t.scopedSlots,u.$slots=ke(n,i)),u.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return je(i,t.scopedSlots,this.slots())}}),f&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=je(i,t.scopedSlots,this.$slots)),l._scopeId?this._c=function(t,e,n,r){var a=qe(c,t,e,n,r,d);return a&&!o(a)&&(a.fnScopeId=l._scopeId,a.fnContext=i),a}:this._c=function(t,e,n,r){return qe(c,t,e,n,r,d)}}function nr(t,e,n,i,s){var c=t.options,u={},l=c.props;if(a(l))for(var f in l)u[f]=Or(f,l,e||r);else a(n.attrs)&&or(u,n.attrs),a(n.props)&&or(u,n.props);var d=new er(n,u,s,i,t),p=c.render.call(null,d._c,d);if(p instanceof yt)return rr(p,n,d.parent,c,d);if(o(p)){for(var v=se(p)||[],h=new Array(v.length),m=0;m<v.length;m++)h[m]=rr(v[m],n,d.parent,c,d);return h}}function rr(t,e,n,r,o){var i=wt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function or(t,e){for(var n in e)t[S(n)]=e[n]}function ir(t){return t.name||t.__name||t._componentTag}xe(er.prototype);var ar={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var n=t;ar.prepatch(n,n)}else{var r=t.componentInstance=ur(t,On);r.$mount(e?t.elm:void 0,e)}},prepatch:function(t,e){var n=e.componentOptions,r=e.componentInstance=t.componentInstance;En(r,n.propsData,n.listeners,e,n.children)},insert:function(t){var e=t.context,n=t.componentInstance;n._isMounted||(n._isMounted=!0,Dn(n,"mounted")),t.data.keepAlive&&(e._isMounted?Jn(n):Pn(n,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?Nn(e,!0):e.$destroy())}},sr=Object.keys(ar);function cr(t,e,n,r,o){if(!i(t)){var c=n.$options._base;if(f(t)&&(t=c.extend(t)),"function"===typeof t){var u;if(i(t.cid)&&(u=t,t=Ve(u,c),void 0===t))return Be(u,e,n,r,o);e=e||{},Xr(t),a(e.model)&&dr(t.options,e);var l=oe(e,t,o);if(s(t.options.functional))return nr(t,l,e,n,r);var d=e.on;if(e.on=e.nativeOn,s(t.options.abstract)){var p=e.slot;e={},p&&(e.slot=p)}lr(e);var v=ir(t.options)||o,h=new yt("vue-component-".concat(t.cid).concat(v?"-".concat(v):""),e,void 0,void 0,void 0,n,{Ctor:t,propsData:l,listeners:d,tag:o,children:r},u);return h}}}function ur(t,e){var n={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;return a(r)&&(n.render=r.render,n.staticRenderFns=r.staticRenderFns),new t.componentOptions.Ctor(n)}function lr(t){for(var e=t.hook||(t.hook={}),n=0;n<sr.length;n++){var r=sr[n],o=e[r],i=ar[r];o===i||o&&o._merged||(e[r]=o?fr(i,o):i)}}function fr(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function dr(t,e){var n=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[n]=e.model.value;var i=e.on||(e.on={}),s=i[r],c=e.model.callback;a(s)?(o(s)?-1===s.indexOf(c):s!==c)&&(i[r]=[c].concat(s)):i[r]=c}var pr=L,vr=K.optionMergeStrategies;function hr(t,e,n){if(void 0===n&&(n=!0),!e)return t;for(var r,o,i,a=ht?Reflect.ownKeys(e):Object.keys(e),s=0;s<a.length;s++)r=a[s],"__ob__"!==r&&(o=t[r],i=e[r],n&&x(t,r)?o!==i&&p(o)&&p(i)&&hr(o,i):Ut(t,r,i));return t}function mr(t,e,n){return n?function(){var r=l(e)?e.call(n,n):e,o=l(t)?t.call(n,n):t;return r?hr(r,o):o}:e?t?function(){return hr(l(e)?e.call(this,this):e,l(t)?t.call(this,this):t)}:e:t}function _r(t,e){var n=e?t?t.concat(e):o(e)?e:[e]:t;return n?yr(n):n}function yr(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}function gr(t,e,n,r){var o=Object.create(t||null);return e?D(o,e):o}vr.data=function(t,e,n){return n?mr(t,e,n):e&&"function"!==typeof e?t:mr(t,e)},q.forEach((function(t){vr[t]=_r})),W.forEach((function(t){vr[t+"s"]=gr})),vr.watch=function(t,e,n,r){if(t===ct&&(t=void 0),e===ct&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var i={};for(var a in D(i,t),e){var s=i[a],c=e[a];s&&!o(s)&&(s=[s]),i[a]=s?s.concat(c):o(c)?c:[c]}return i},vr.props=vr.methods=vr.inject=vr.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return D(o,t),e&&D(o,e),o},vr.provide=function(t,e){return t?function(){var n=Object.create(null);return hr(n,l(t)?t.call(this):t),e&&hr(n,l(e)?e.call(this):e,!1),n}:e};var br=function(t,e){return void 0===e?t:e};function wr(t,e){var n=t.props;if(n){var r,i,a,s={};if(o(n)){r=n.length;while(r--)i=n[r],"string"===typeof i&&(a=S(i),s[a]={type:null})}else if(p(n))for(var c in n)i=n[c],a=S(c),s[a]=p(i)?i:{type:i};else 0;t.props=s}}function Cr(t,e){var n=t.inject;if(n){var r=t.inject={};if(o(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(p(n))for(var a in n){var s=n[a];r[a]=p(s)?D({from:a},s):{from:s}}else 0}}function $r(t){var e=t.directives;if(e)for(var n in e){var r=e[n];l(r)&&(e[n]={bind:r,update:r})}}function xr(t,e,n){if(l(e)&&(e=e.options),wr(e,n),Cr(e,n),$r(e),!e._base&&(e.extends&&(t=xr(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=xr(t,e.mixins[r],n);var i,a={};for(i in t)s(i);for(i in e)x(t,i)||s(i);function s(r){var o=vr[r]||br;a[r]=o(t[r],e[r],n,r)}return a}function kr(t,e,n,r){if("string"===typeof n){var o=t[e];if(x(o,n))return o[n];var i=S(n);if(x(o,i))return o[i];var a=j(i);if(x(o,a))return o[a];var s=o[n]||o[i]||o[a];return s}}function Or(t,e,n,r){var o=e[t],i=!x(n,t),a=n[t],s=Er(Boolean,o.type);if(s>-1)if(i&&!x(o,"default"))a=!1;else if(""===a||a===A(t)){var c=Er(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=Sr(r,o,t);var u=Nt;Dt(!0),Ft(a),Dt(u)}return a}function Sr(t,e,n){if(x(e,"default")){var r=e.default;return t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n]?t._props[n]:l(r)&&"Function"!==Tr(e.type)?r.call(t):r}}var jr=/^\s*function (\w+)/;function Tr(t){var e=t&&t.toString().match(jr);return e?e[1]:""}function Ar(t,e){return Tr(t)===Tr(e)}function Er(t,e){if(!o(e))return Ar(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Ar(e[n],t))return n;return-1}var Ir={enumerable:!0,configurable:!0,get:L,set:L};function Pr(t,e,n){Ir.get=function(){return this[e][n]},Ir.set=function(t){this[e][n]=t},Object.defineProperty(t,n,Ir)}function Nr(t){var e=t.$options;if(e.props&&Dr(t,e.props),Ee(t),e.methods&&Hr(t,e.methods),e.data)Mr(t);else{var n=Ft(t._data={});n&&n.vmCount++}e.computed&&Rr(t,e.computed),e.watch&&e.watch!==ct&&zr(t,e.watch)}function Dr(t,e){var n=t.$options.propsData||{},r=t._props=Ht({}),o=t.$options._propKeys=[],i=!t.$parent;i||Dt(!1);var a=function(i){o.push(i);var a=Or(i,e,n,t);Rt(r,i,a,void 0,!0),i in t||Pr(t,"_props",i)};for(var s in e)a(s);Dt(!0)}function Mr(t){var e=t.$options.data;e=t._data=l(e)?Lr(e,t):e||{},p(e)||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);while(o--){var i=n[o];0,r&&x(r,i)||J(i)||Pr(t,"_data",i)}var a=Ft(e);a&&a.vmCount++}function Lr(t,e){St();try{return t.call(e,e)}catch(Ya){return Xe(Ya,e,"data()"),{}}finally{jt()}}var Fr={lazy:!0};function Rr(t,e){var n=t._computedWatchers=Object.create(null),r=ft();for(var o in e){var i=e[o],a=l(i)?i:i.get;0,r||(n[o]=new gn(t,a||L,L,Fr)),o in t||Ur(t,o,i)}}function Ur(t,e,n){var r=!ft();l(n)?(Ir.get=r?Br(e):Vr(n),Ir.set=L):(Ir.get=n.get?r&&!1!==n.cache?Br(e):Vr(n.get):L,Ir.set=n.set||L),Object.defineProperty(t,e,Ir)}function Br(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),kt.target&&e.depend(),e.value}}function Vr(t){return function(){return t.call(this,this)}}function Hr(t,e){t.$options.props;for(var n in e)t[n]="function"!==typeof e[n]?L:P(e[n],t)}function zr(t,e){for(var n in e){var r=e[n];if(o(r))for(var i=0;i<r.length;i++)Wr(t,n,r[i]);else Wr(t,n,r)}}function Wr(t,e,n,r){return p(n)&&(r=n,n=n.handler),"string"===typeof n&&(n=t[n]),t.$watch(e,n,r)}function qr(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ut,t.prototype.$delete=Bt,t.prototype.$watch=function(t,e,n){var r=this;if(p(e))return Wr(r,t,e,n);n=n||{},n.user=!0;var o=new gn(r,t,e,n);if(n.immediate){var i='callback for immediate watcher "'.concat(o.expression,'"');St(),Ze(e,r,[o.value],r,i),jt()}return function(){o.teardown()}}}var Kr=0;function Gr(t){t.prototype._init=function(t){var e=this;e._uid=Kr++,e._isVue=!0,e.__v_skip=!0,e._scope=new Xt(!0),e._scope.parent=void 0,e._scope._vm=!0,t&&t._isComponent?Jr(e,t):e.$options=xr(Xr(e.constructor),t||{},e),e._renderProxy=e,e._self=e,jn(e),bn(e),Le(e),Dn(e,"beforeCreate",void 0,!1),Yn(e),Nr(e),Qn(e),Dn(e,"created"),e.$options.el&&e.$mount(e.$options.el)}}function Jr(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}function Xr(t){var e=t.options;if(t.super){var n=Xr(t.super),r=t.superOptions;if(n!==r){t.superOptions=n;var o=Zr(t);o&&D(t.extendOptions,o),e=t.options=xr(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function Zr(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}function Qr(t){this._init(t)}function Yr(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=N(arguments,1);return n.unshift(this),l(t.install)?t.install.apply(t,n):l(t)&&t.apply(null,n),e.push(t),this}}function to(t){t.mixin=function(t){return this.options=xr(this.options,t),this}}function eo(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=ir(t)||ir(n.options);var a=function(t){this._init(t)};return a.prototype=Object.create(n.prototype),a.prototype.constructor=a,a.cid=e++,a.options=xr(n.options,t),a["super"]=n,a.options.props&&no(a),a.options.computed&&ro(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,W.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=D({},a.options),o[r]=a,a}}function no(t){var e=t.options.props;for(var n in e)Pr(t.prototype,"_props",n)}function ro(t){var e=t.options.computed;for(var n in e)Ur(t.prototype,n,e[n])}function oo(t){W.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&p(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&l(n)&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}function io(t){return t&&(ir(t.Ctor.options)||t.tag)}function ao(t,e){return o(t)?t.indexOf(e)>-1:"string"===typeof t?t.split(",").indexOf(e)>-1:!!v(t)&&t.test(e)}function so(t,e){var n=t.cache,r=t.keys,o=t._vnode,i=t.$vnode;for(var a in n){var s=n[a];if(s){var c=s.name;c&&!e(c)&&co(n,a,r,o)}}i.componentOptions.children=void 0}function co(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,C(n,e)}Gr(Qr),qr(Qr),kn(Qr),Tn(Qr),Re(Qr);var uo=[String,RegExp,Array],lo={name:"keep-alive",abstract:!0,props:{include:uo,exclude:uo,max:[String,Number]},methods:{cacheVNode:function(){var t=this,e=t.cache,n=t.keys,r=t.vnodeToCache,o=t.keyToCache;if(r){var i=r.tag,a=r.componentInstance,s=r.componentOptions;e[o]={name:io(s),tag:i,componentInstance:a},n.push(o),this.max&&n.length>parseInt(this.max)&&co(e,n[0],n,this._vnode),this.vnodeToCache=null}}},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)co(this.cache,t,this.keys)},mounted:function(){var t=this;this.cacheVNode(),this.$watch("include",(function(e){so(t,(function(t){return ao(e,t)}))})),this.$watch("exclude",(function(e){so(t,(function(t){return!ao(e,t)}))}))},updated:function(){this.cacheVNode()},render:function(){var t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){var r=io(n),o=this,i=o.include,a=o.exclude;if(i&&(!r||!ao(i,r))||a&&r&&ao(a,r))return e;var s=this,c=s.cache,u=s.keys,l=null==e.key?n.Ctor.cid+(n.tag?"::".concat(n.tag):""):e.key;c[l]?(e.componentInstance=c[l].componentInstance,C(u,l),u.push(l)):(this.vnodeToCache=e,this.keyToCache=l),e.data.keepAlive=!0}return e||t&&t[0]}},fo={KeepAlive:lo};function po(t){var e={get:function(){return K}};Object.defineProperty(t,"config",e),t.util={warn:pr,extend:D,mergeOptions:xr,defineReactive:Rt},t.set=Ut,t.delete=Bt,t.nextTick=ln,t.observable=function(t){return Ft(t),t},t.options=Object.create(null),W.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,D(t.options.components,fo),Yr(t),to(t),eo(t),oo(t)}po(Qr),Object.defineProperty(Qr.prototype,"$isServer",{get:ft}),Object.defineProperty(Qr.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Qr,"FunctionalRenderContext",{value:er}),Qr.version=pn;var vo=b("style,class"),ho=b("input,textarea,option,select,progress"),mo=function(t,e,n){return"value"===n&&ho(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},_o=b("contenteditable,draggable,spellcheck"),yo=b("events,caret,typing,plaintext-only"),go=function(t,e){return xo(e)||"false"===e?"false":"contenteditable"===t&&yo(e)?e:"true"},bo=b("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),wo="http://www.w3.org/1999/xlink",Co=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},$o=function(t){return Co(t)?t.slice(6,t.length):""},xo=function(t){return null==t||!1===t};function ko(t){var e=t.data,n=t,r=t;while(a(r.componentInstance))r=r.componentInstance._vnode,r&&r.data&&(e=Oo(r.data,e));while(a(n=n.parent))n&&n.data&&(e=Oo(e,n.data));return So(e.staticClass,e.class)}function Oo(t,e){return{staticClass:jo(t.staticClass,e.staticClass),class:a(t.class)?[t.class,e.class]:e.class}}function So(t,e){return a(t)||a(e)?jo(t,To(e)):""}function jo(t,e){return t?e?t+" "+e:t:e||""}function To(t){return Array.isArray(t)?Ao(t):f(t)?Eo(t):"string"===typeof t?t:""}function Ao(t){for(var e,n="",r=0,o=t.length;r<o;r++)a(e=To(t[r]))&&""!==e&&(n&&(n+=" "),n+=e);return n}function Eo(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}var Io={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Po=b("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),No=b("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Do=function(t){return Po(t)||No(t)};function Mo(t){return No(t)?"svg":"math"===t?"math":void 0}var Lo=Object.create(null);function Fo(t){if(!tt)return!0;if(Do(t))return!1;if(t=t.toLowerCase(),null!=Lo[t])return Lo[t];var e=document.createElement(t);return t.indexOf("-")>-1?Lo[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Lo[t]=/HTMLUnknownElement/.test(e.toString())}var Ro=b("text,number,password,search,email,tel,url");function Uo(t){if("string"===typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}function Bo(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n}function Vo(t,e){return document.createElementNS(Io[t],e)}function Ho(t){return document.createTextNode(t)}function zo(t){return document.createComment(t)}function Wo(t,e,n){t.insertBefore(e,n)}function qo(t,e){t.removeChild(e)}function Ko(t,e){t.appendChild(e)}function Go(t){return t.parentNode}function Jo(t){return t.nextSibling}function Xo(t){return t.tagName}function Zo(t,e){t.textContent=e}function Qo(t,e){t.setAttribute(e,"")}var Yo=Object.freeze({__proto__:null,createElement:Bo,createElementNS:Vo,createTextNode:Ho,createComment:zo,insertBefore:Wo,removeChild:qo,appendChild:Ko,parentNode:Go,nextSibling:Jo,tagName:Xo,setTextContent:Zo,setStyleScope:Qo}),ti={create:function(t,e){ei(e)},update:function(t,e){t.data.ref!==e.data.ref&&(ei(t,!0),ei(e))},destroy:function(t){ei(t,!0)}};function ei(t,e){var n=t.data.ref;if(a(n)){var r=t.context,i=t.componentInstance||t.elm,s=e?null:i,c=e?void 0:i;if(l(n))Ze(n,r,[s],r,"template ref function");else{var u=t.data.refInFor,f="string"===typeof n||"number"===typeof n,d=qt(n),p=r.$refs;if(f||d)if(u){var v=f?p[n]:n.value;e?o(v)&&C(v,i):o(v)?v.includes(i)||v.push(i):f?(p[n]=[i],ni(r,n,p[n])):n.value=[i]}else if(f){if(e&&p[n]!==i)return;p[n]=c,ni(r,n,s)}else if(d){if(e&&n.value!==i)return;n.value=s}else 0}}}function ni(t,e,n){var r=t._setupState;r&&x(r,e)&&(qt(r[e])?r[e].value=n:r[e]=n)}var ri=new yt("",{},[]),oi=["create","activate","update","remove","destroy"];function ii(t,e){return t.key===e.key&&t.asyncFactory===e.asyncFactory&&(t.tag===e.tag&&t.isComment===e.isComment&&a(t.data)===a(e.data)&&ai(t,e)||s(t.isAsyncPlaceholder)&&i(e.asyncFactory.error))}function ai(t,e){if("input"!==t.tag)return!0;var n,r=a(n=t.data)&&a(n=n.attrs)&&n.type,o=a(n=e.data)&&a(n=n.attrs)&&n.type;return r===o||Ro(r)&&Ro(o)}function si(t,e,n){var r,o,i={};for(r=e;r<=n;++r)o=t[r].key,a(o)&&(i[o]=r);return i}function ci(t){var e,n,r={},c=t.modules,l=t.nodeOps;for(e=0;e<oi.length;++e)for(r[oi[e]]=[],n=0;n<c.length;++n)a(c[n][oi[e]])&&r[oi[e]].push(c[n][oi[e]]);function f(t){return new yt(l.tagName(t).toLowerCase(),{},[],void 0,t)}function d(t,e){function n(){0===--n.listeners&&p(t)}return n.listeners=e,n}function p(t){var e=l.parentNode(t);a(e)&&l.removeChild(e,t)}function v(t,e,n,r,o,i,c){if(a(t.elm)&&a(i)&&(t=i[c]=wt(t)),t.isRootInsert=!o,!h(t,e,n,r)){var u=t.data,f=t.children,d=t.tag;a(d)?(t.elm=t.ns?l.createElementNS(t.ns,d):l.createElement(d,t),$(t),g(t,f,e),a(u)&&C(t,e),y(n,t.elm,r)):s(t.isComment)?(t.elm=l.createComment(t.text),y(n,t.elm,r)):(t.elm=l.createTextNode(t.text),y(n,t.elm,r))}}function h(t,e,n,r){var o=t.data;if(a(o)){var i=a(t.componentInstance)&&o.keepAlive;if(a(o=o.hook)&&a(o=o.init)&&o(t,!1),a(t.componentInstance))return m(t,e),y(n,t.elm,r),s(i)&&_(t,e,n,r),!0}}function m(t,e){a(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,w(t)?(C(t,e),$(t)):(ei(t),e.push(t))}function _(t,e,n,o){var i,s=t;while(s.componentInstance)if(s=s.componentInstance._vnode,a(i=s.data)&&a(i=i.transition)){for(i=0;i<r.activate.length;++i)r.activate[i](ri,s);e.push(s);break}y(n,t.elm,o)}function y(t,e,n){a(t)&&(a(n)?l.parentNode(n)===t&&l.insertBefore(t,e,n):l.appendChild(t,e))}function g(t,e,n){if(o(e)){0;for(var r=0;r<e.length;++r)v(e[r],n,t.elm,null,!0,e,r)}else u(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function w(t){while(t.componentInstance)t=t.componentInstance._vnode;return a(t.tag)}function C(t,n){for(var o=0;o<r.create.length;++o)r.create[o](ri,t);e=t.data.hook,a(e)&&(a(e.create)&&e.create(ri,t),a(e.insert)&&n.push(t))}function $(t){var e;if(a(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{var n=t;while(n)a(e=n.context)&&a(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),n=n.parent}a(e=On)&&e!==t.context&&e!==t.fnContext&&a(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function x(t,e,n,r,o,i){for(;r<=o;++r)v(n[r],i,t,e,!1,n,r)}function k(t){var e,n,o=t.data;if(a(o))for(a(e=o.hook)&&a(e=e.destroy)&&e(t),e=0;e<r.destroy.length;++e)r.destroy[e](t);if(a(e=t.children))for(n=0;n<t.children.length;++n)k(t.children[n])}function O(t,e,n){for(;e<=n;++e){var r=t[e];a(r)&&(a(r.tag)?(S(r),k(r)):p(r.elm))}}function S(t,e){if(a(e)||a(t.data)){var n,o=r.remove.length+1;for(a(e)?e.listeners+=o:e=d(t.elm,o),a(n=t.componentInstance)&&a(n=n._vnode)&&a(n.data)&&S(n,e),n=0;n<r.remove.length;++n)r.remove[n](t,e);a(n=t.data.hook)&&a(n=n.remove)?n(t,e):e()}else p(t.elm)}function j(t,e,n,r,o){var s,c,u,f,d=0,p=0,h=e.length-1,m=e[0],_=e[h],y=n.length-1,g=n[0],b=n[y],w=!o;while(d<=h&&p<=y)i(m)?m=e[++d]:i(_)?_=e[--h]:ii(m,g)?(A(m,g,r,n,p),m=e[++d],g=n[++p]):ii(_,b)?(A(_,b,r,n,y),_=e[--h],b=n[--y]):ii(m,b)?(A(m,b,r,n,y),w&&l.insertBefore(t,m.elm,l.nextSibling(_.elm)),m=e[++d],b=n[--y]):ii(_,g)?(A(_,g,r,n,p),w&&l.insertBefore(t,_.elm,m.elm),_=e[--h],g=n[++p]):(i(s)&&(s=si(e,d,h)),c=a(g.key)?s[g.key]:T(g,e,d,h),i(c)?v(g,r,t,m.elm,!1,n,p):(u=e[c],ii(u,g)?(A(u,g,r,n,p),e[c]=void 0,w&&l.insertBefore(t,u.elm,m.elm)):v(g,r,t,m.elm,!1,n,p)),g=n[++p]);d>h?(f=i(n[y+1])?null:n[y+1].elm,x(t,f,n,p,y,r)):p>y&&O(e,d,h)}function T(t,e,n,r){for(var o=n;o<r;o++){var i=e[o];if(a(i)&&ii(t,i))return o}}function A(t,e,n,o,c,u){if(t!==e){a(e.elm)&&a(o)&&(e=o[c]=wt(e));var f=e.elm=t.elm;if(s(t.isAsyncPlaceholder))a(e.asyncFactory.resolved)?P(t.elm,e,n):e.isAsyncPlaceholder=!0;else if(s(e.isStatic)&&s(t.isStatic)&&e.key===t.key&&(s(e.isCloned)||s(e.isOnce)))e.componentInstance=t.componentInstance;else{var d,p=e.data;a(p)&&a(d=p.hook)&&a(d=d.prepatch)&&d(t,e);var v=t.children,h=e.children;if(a(p)&&w(e)){for(d=0;d<r.update.length;++d)r.update[d](t,e);a(d=p.hook)&&a(d=d.update)&&d(t,e)}i(e.text)?a(v)&&a(h)?v!==h&&j(f,v,h,n,u):a(h)?(a(t.text)&&l.setTextContent(f,""),x(f,null,h,0,h.length-1,n)):a(v)?O(v,0,v.length-1):a(t.text)&&l.setTextContent(f,""):t.text!==e.text&&l.setTextContent(f,e.text),a(p)&&a(d=p.hook)&&a(d=d.postpatch)&&d(t,e)}}}function E(t,e,n){if(s(n)&&a(t.parent))t.parent.data.pendingInsert=e;else for(var r=0;r<e.length;++r)e[r].data.hook.insert(e[r])}var I=b("attrs,class,staticClass,staticStyle,key");function P(t,e,n,r){var o,i=e.tag,c=e.data,u=e.children;if(r=r||c&&c.pre,e.elm=t,s(e.isComment)&&a(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(a(c)&&(a(o=c.hook)&&a(o=o.init)&&o(e,!0),a(o=e.componentInstance)))return m(e,n),!0;if(a(i)){if(a(u))if(t.hasChildNodes())if(a(o=c)&&a(o=o.domProps)&&a(o=o.innerHTML)){if(o!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!P(f,u[d],n,r)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else g(e,u,n);if(a(c)){var p=!1;for(var v in c)if(!I(v)){p=!0,C(e,n);break}!p&&c["class"]&&hn(c["class"])}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,e,n,o){if(!i(e)){var c=!1,u=[];if(i(t))c=!0,v(e,u);else{var d=a(t.nodeType);if(!d&&ii(t,e))A(t,e,u,null,null,o);else{if(d){if(1===t.nodeType&&t.hasAttribute(z)&&(t.removeAttribute(z),n=!0),s(n)&&P(t,e,u))return E(e,u,!0),t;t=f(t)}var p=t.elm,h=l.parentNode(p);if(v(e,u,p._leaveCb?null:h,l.nextSibling(p)),a(e.parent)){var m=e.parent,_=w(e);while(m){for(var y=0;y<r.destroy.length;++y)r.destroy[y](m);if(m.elm=e.elm,_){for(var g=0;g<r.create.length;++g)r.create[g](ri,m);var b=m.data.hook.insert;if(b.merged)for(var C=b.fns.slice(1),$=0;$<C.length;$++)C[$]()}else ei(m);m=m.parent}}a(h)?O([t],0,0):a(t.tag)&&k(t)}}return E(e,u,c),e.elm}a(t)&&k(t)}}var ui={create:li,update:li,destroy:function(t){li(t,ri)}};function li(t,e){(t.data.directives||e.data.directives)&&fi(t,e)}function fi(t,e){var n,r,o,i=t===ri,a=e===ri,s=pi(t.data.directives,t.context),c=pi(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,hi(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(hi(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)hi(u[n],"inserted",e,t)};i?re(e,"insert",f):f()}if(l.length&&re(e,"postpatch",(function(){for(var n=0;n<l.length;n++)hi(l[n],"componentUpdated",e,t)})),!i)for(n in s)c[n]||hi(s[n],"unbind",t,t,a)}var di=Object.create(null);function pi(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++){if(r=t[n],r.modifiers||(r.modifiers=di),o[vi(r)]=r,e._setupState&&e._setupState.__sfc){var i=r.def||kr(e,"_setupState","v-"+r.name);r.def="function"===typeof i?{bind:i,update:i}:i}r.def=r.def||kr(e.$options,"directives",r.name,!0)}return o}function vi(t){return t.rawName||"".concat(t.name,".").concat(Object.keys(t.modifiers||{}).join("."))}function hi(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(Ya){Xe(Ya,n.context,"directive ".concat(t.name," ").concat(e," hook"))}}var mi=[ti,ui];function _i(t,e){var n=e.componentOptions;if((!a(n)||!1!==n.Ctor.options.inheritAttrs)&&(!i(t.data.attrs)||!i(e.data.attrs))){var r,o,c,u=e.elm,l=t.data.attrs||{},f=e.data.attrs||{};for(r in(a(f.__ob__)||s(f._v_attr_proxy))&&(f=e.data.attrs=D({},f)),f)o=f[r],c=l[r],c!==o&&yi(u,r,o,e.data.pre);for(r in(nt||ot)&&f.value!==l.value&&yi(u,"value",f.value),l)i(f[r])&&(Co(r)?u.removeAttributeNS(wo,$o(r)):_o(r)||u.removeAttribute(r))}}function yi(t,e,n,r){r||t.tagName.indexOf("-")>-1?gi(t,e,n):bo(e)?xo(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):_o(e)?t.setAttribute(e,go(e,n)):Co(e)?xo(n)?t.removeAttributeNS(wo,$o(e)):t.setAttributeNS(wo,e,n):gi(t,e,n)}function gi(t,e,n){if(xo(n))t.removeAttribute(e);else{if(nt&&!rt&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var bi={create:_i,update:_i};function wi(t,e){var n=e.elm,r=e.data,o=t.data;if(!(i(r.staticClass)&&i(r.class)&&(i(o)||i(o.staticClass)&&i(o.class)))){var s=ko(e),c=n._transitionClasses;a(c)&&(s=jo(s,To(c))),s!==n._prevClass&&(n.setAttribute("class",s),n._prevClass=s)}}var Ci,$i={create:wi,update:wi},xi="__r",ki="__c";function Oi(t){if(a(t[xi])){var e=nt?"change":"input";t[e]=[].concat(t[xi],t[e]||[]),delete t[xi]}a(t[ki])&&(t.change=[].concat(t[ki],t.change||[]),delete t[ki])}function Si(t,e,n){var r=Ci;return function o(){var i=e.apply(null,arguments);null!==i&&Ai(t,o,n,r)}}var ji=en&&!(st&&Number(st[1])<=53);function Ti(t,e,n,r){if(ji){var o=Hn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}Ci.addEventListener(t,e,ut?{capture:n,passive:r}:n)}function Ai(t,e,n,r){(r||Ci).removeEventListener(t,e._wrapper||e,n)}function Ei(t,e){if(!i(t.data.on)||!i(e.data.on)){var n=e.data.on||{},r=t.data.on||{};Ci=e.elm||t.elm,Oi(n),ne(n,r,Ti,Ai,Si,e.context),Ci=void 0}}var Ii,Pi={create:Ei,update:Ei,destroy:function(t){return Ei(t,ri)}};function Ni(t,e){if(!i(t.data.domProps)||!i(e.data.domProps)){var n,r,o=e.elm,c=t.data.domProps||{},u=e.data.domProps||{};for(n in(a(u.__ob__)||s(u._v_attr_proxy))&&(u=e.data.domProps=D({},u)),c)n in u||(o[n]="");for(n in u){if(r=u[n],"textContent"===n||"innerHTML"===n){if(e.children&&(e.children.length=0),r===c[n])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===n&&"PROGRESS"!==o.tagName){o._value=r;var l=i(r)?"":String(r);Di(o,l)&&(o.value=l)}else if("innerHTML"===n&&No(o.tagName)&&i(o.innerHTML)){Ii=Ii||document.createElement("div"),Ii.innerHTML="<svg>".concat(r,"</svg>");var f=Ii.firstChild;while(o.firstChild)o.removeChild(o.firstChild);while(f.firstChild)o.appendChild(f.firstChild)}else if(r!==c[n])try{o[n]=r}catch(Ya){}}}}function Di(t,e){return!t.composing&&("OPTION"===t.tagName||Mi(t,e)||Li(t,e))}function Mi(t,e){var n=!0;try{n=document.activeElement!==t}catch(Ya){}return n&&t.value!==e}function Li(t,e){var n=t.value,r=t._vModifiers;if(a(r)){if(r.number)return g(n)!==g(e);if(r.trim)return n.trim()!==e.trim()}return n!==e}var Fi={create:Ni,update:Ni},Ri=k((function(t){var e={},n=/;(?![^(]*\))/g,r=/:(.+)/;return t.split(n).forEach((function(t){if(t){var n=t.split(r);n.length>1&&(e[n[0].trim()]=n[1].trim())}})),e}));function Ui(t){var e=Bi(t.style);return t.staticStyle?D(t.staticStyle,e):e}function Bi(t){return Array.isArray(t)?M(t):"string"===typeof t?Ri(t):t}function Vi(t,e){var n,r={};if(e){var o=t;while(o.componentInstance)o=o.componentInstance._vnode,o&&o.data&&(n=Ui(o.data))&&D(r,n)}(n=Ui(t.data))&&D(r,n);var i=t;while(i=i.parent)i.data&&(n=Ui(i.data))&&D(r,n);return r}var Hi,zi=/^--/,Wi=/\s*!important$/,qi=function(t,e,n){if(zi.test(e))t.style.setProperty(e,n);else if(Wi.test(n))t.style.setProperty(A(e),n.replace(Wi,""),"important");else{var r=Gi(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Ki=["Webkit","Moz","ms"],Gi=k((function(t){if(Hi=Hi||document.createElement("div").style,t=S(t),"filter"!==t&&t in Hi)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Ki.length;n++){var r=Ki[n]+e;if(r in Hi)return r}}));function Ji(t,e){var n=e.data,r=t.data;if(!(i(n.staticStyle)&&i(n.style)&&i(r.staticStyle)&&i(r.style))){var o,s,c=e.elm,u=r.staticStyle,l=r.normalizedStyle||r.style||{},f=u||l,d=Bi(e.data.style)||{};e.data.normalizedStyle=a(d.__ob__)?D({},d):d;var p=Vi(e,!0);for(s in f)i(p[s])&&qi(c,s,"");for(s in p)o=p[s],qi(c,s,null==o?"":o)}}var Xi={create:Ji,update:Ji},Zi=/\s+/;function Qi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Zi).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" ".concat(t.getAttribute("class")||""," ");n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Yi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Zi).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{var n=" ".concat(t.getAttribute("class")||""," "),r=" "+e+" ";while(n.indexOf(r)>=0)n=n.replace(r," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function ta(t){if(t){if("object"===typeof t){var e={};return!1!==t.css&&D(e,ea(t.name||"v")),D(e,t),e}return"string"===typeof t?ea(t):void 0}}var ea=k((function(t){return{enterClass:"".concat(t,"-enter"),enterToClass:"".concat(t,"-enter-to"),enterActiveClass:"".concat(t,"-enter-active"),leaveClass:"".concat(t,"-leave"),leaveToClass:"".concat(t,"-leave-to"),leaveActiveClass:"".concat(t,"-leave-active")}})),na=tt&&!rt,ra="transition",oa="animation",ia="transition",aa="transitionend",sa="animation",ca="animationend";na&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ia="WebkitTransition",aa="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(sa="WebkitAnimation",ca="webkitAnimationEnd"));var ua=tt?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function la(t){ua((function(){ua(t)}))}function fa(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Qi(t,e))}function da(t,e){t._transitionClasses&&C(t._transitionClasses,e),Yi(t,e)}function pa(t,e,n){var r=ha(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===ra?aa:ca,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var va=/\b(transform|all)(,|$)/;function ha(t,e){var n,r=window.getComputedStyle(t),o=(r[ia+"Delay"]||"").split(", "),i=(r[ia+"Duration"]||"").split(", "),a=ma(o,i),s=(r[sa+"Delay"]||"").split(", "),c=(r[sa+"Duration"]||"").split(", "),u=ma(s,c),l=0,f=0;e===ra?a>0&&(n=ra,l=a,f=i.length):e===oa?u>0&&(n=oa,l=u,f=c.length):(l=Math.max(a,u),n=l>0?a>u?ra:oa:null,f=n?n===ra?i.length:c.length:0);var d=n===ra&&va.test(r[ia+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}function ma(t,e){while(t.length<e.length)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return _a(e)+_a(t[n])})))}function _a(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ya(t,e){var n=t.elm;a(n._leaveCb)&&(n._leaveCb.cancelled=!0,n._leaveCb());var r=ta(t.data.transition);if(!i(r)&&!a(n._enterCb)&&1===n.nodeType){var o=r.css,s=r.type,c=r.enterClass,u=r.enterToClass,d=r.enterActiveClass,p=r.appearClass,v=r.appearToClass,h=r.appearActiveClass,m=r.beforeEnter,_=r.enter,y=r.afterEnter,b=r.enterCancelled,w=r.beforeAppear,C=r.appear,$=r.afterAppear,x=r.appearCancelled,k=r.duration,O=On,S=On.$vnode;while(S&&S.parent)O=S.context,S=S.parent;var j=!O._isMounted||!t.isRootInsert;if(!j||C||""===C){var T=j&&p?p:c,A=j&&h?h:d,E=j&&v?v:u,I=j&&w||m,P=j&&l(C)?C:_,N=j&&$||y,D=j&&x||b,M=g(f(k)?k.enter:k);0;var L=!1!==o&&!rt,F=wa(P),R=n._enterCb=V((function(){L&&(da(n,E),da(n,A)),R.cancelled?(L&&da(n,T),D&&D(n)):N&&N(n),n._enterCb=null}));t.data.show||re(t,"insert",(function(){var e=n.parentNode,r=e&&e._pending&&e._pending[t.key];r&&r.tag===t.tag&&r.elm._leaveCb&&r.elm._leaveCb(),P&&P(n,R)})),I&&I(n),L&&(fa(n,T),fa(n,A),la((function(){da(n,T),R.cancelled||(fa(n,E),F||(ba(M)?setTimeout(R,M):pa(n,s,R)))}))),t.data.show&&(e&&e(),P&&P(n,R)),L||F||R()}}}function ga(t,e){var n=t.elm;a(n._enterCb)&&(n._enterCb.cancelled=!0,n._enterCb());var r=ta(t.data.transition);if(i(r)||1!==n.nodeType)return e();if(!a(n._leaveCb)){var o=r.css,s=r.type,c=r.leaveClass,u=r.leaveToClass,l=r.leaveActiveClass,d=r.beforeLeave,p=r.leave,v=r.afterLeave,h=r.leaveCancelled,m=r.delayLeave,_=r.duration,y=!1!==o&&!rt,b=wa(p),w=g(f(_)?_.leave:_);0;var C=n._leaveCb=V((function(){n.parentNode&&n.parentNode._pending&&(n.parentNode._pending[t.key]=null),y&&(da(n,u),da(n,l)),C.cancelled?(y&&da(n,c),h&&h(n)):(e(),v&&v(n)),n._leaveCb=null}));m?m($):$()}function $(){C.cancelled||(!t.data.show&&n.parentNode&&((n.parentNode._pending||(n.parentNode._pending={}))[t.key]=t),d&&d(n),y&&(fa(n,c),fa(n,l),la((function(){da(n,c),C.cancelled||(fa(n,u),b||(ba(w)?setTimeout(C,w):pa(n,s,C)))}))),p&&p(n,C),y||b||C())}}function ba(t){return"number"===typeof t&&!isNaN(t)}function wa(t){if(i(t))return!1;var e=t.fns;return a(e)?wa(Array.isArray(e)?e[0]:e):(t._length||t.length)>1}function Ca(t,e){!0!==e.data.show&&ya(e)}var $a=tt?{create:Ca,activate:Ca,remove:function(t,e){!0!==t.data.show?ga(t,e):e()}}:{},xa=[bi,$i,Pi,Fi,Xi,$a],ka=xa.concat(mi),Oa=ci({nodeOps:Yo,modules:ka});rt&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&Na(t,"input")}));var Sa={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?re(n,"postpatch",(function(){Sa.componentUpdated(t,e,n)})):ja(t,e,n.context),t._vOptions=[].map.call(t.options,Ea)):("textarea"===n.tag||Ro(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Ia),t.addEventListener("compositionend",Pa),t.addEventListener("change",Pa),rt&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ja(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,Ea);if(o.some((function(t,e){return!U(t,r[e])}))){var i=t.multiple?e.value.some((function(t){return Aa(t,o)})):e.value!==e.oldValue&&Aa(e.value,o);i&&Na(t,"change")}}}};function ja(t,e,n){Ta(t,e,n),(nt||ot)&&setTimeout((function(){Ta(t,e,n)}),0)}function Ta(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=B(r,Ea(a))>-1,a.selected!==i&&(a.selected=i);else if(U(Ea(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function Aa(t,e){return e.every((function(e){return!U(e,t)}))}function Ea(t){return"_value"in t?t._value:t.value}function Ia(t){t.target.composing=!0}function Pa(t){t.target.composing&&(t.target.composing=!1,Na(t.target,"input"))}function Na(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Da(t){return!t.componentInstance||t.data&&t.data.transition?t:Da(t.componentInstance._vnode)}var Ma={bind:function(t,e,n){var r=e.value;n=Da(n);var o=n.data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,ya(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value,o=e.oldValue;if(!r!==!o){n=Da(n);var i=n.data&&n.data.transition;i?(n.data.show=!0,r?ya(n,(function(){t.style.display=t.__vOriginalDisplay})):ga(n,(function(){t.style.display="none"}))):t.style.display=r?t.__vOriginalDisplay:"none"}},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}},La={model:Sa,show:Ma},Fa={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ra(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ra(He(e.children)):t}function Ua(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[S(r)]=o[r];return e}function Ba(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}function Va(t){while(t=t.parent)if(t.data.transition)return!0}function Ha(t,e){return e.key===t.key&&e.tag===t.tag}var za=function(t){return t.tag||Se(t)},Wa=function(t){return"show"===t.name},qa={name:"transition",props:Fa,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(za),n.length)){0;var r=this.mode;0;var o=n[0];if(Va(this.$vnode))return o;var i=Ra(o);if(!i)return o;if(this._leaving)return Ba(t,o);var a="__transition-".concat(this._uid,"-");i.key=null==i.key?i.isComment?a+"comment":a+i.tag:u(i.key)?0===String(i.key).indexOf(a)?i.key:a+i.key:i.key;var s=(i.data||(i.data={})).transition=Ua(this),c=this._vnode,l=Ra(c);if(i.data.directives&&i.data.directives.some(Wa)&&(i.data.show=!0),l&&l.data&&!Ha(i,l)&&!Se(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=D({},s);if("out-in"===r)return this._leaving=!0,re(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Ba(t,o);if("in-out"===r){if(Se(i))return c;var d,p=function(){d()};re(s,"afterEnter",p),re(s,"enterCancelled",p),re(f,"delayLeave",(function(t){d=t}))}}return o}}},Ka=D({tag:String,moveClass:String},Fa);delete Ka.mode;var Ga={props:Ka,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Sn(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ua(this),s=0;s<o.length;s++){var c=o[s];if(c.tag)if(null!=c.key&&0!==String(c.key).indexOf("__vlist"))i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a;else;}if(r){var u=[],l=[];for(s=0;s<r.length;s++){c=r[s];c.data.transition=a,c.data.pos=c.elm.getBoundingClientRect(),n[c.key]?u.push(c):l.push(c)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Ja),t.forEach(Xa),t.forEach(Za),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;fa(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(aa,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(aa,t),n._moveCb=null,da(n,e))})}})))},methods:{hasMove:function(t,e){if(!na)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){Yi(n,t)})),Qi(n,e),n.style.display="none",this.$el.appendChild(n);var r=ha(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}};function Ja(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Xa(t){t.data.newPos=t.elm.getBoundingClientRect()}function Za(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate(".concat(r,"px,").concat(o,"px)"),i.transitionDuration="0s"}}var Qa={Transition:qa,TransitionGroup:Ga};Qr.config.mustUseProp=mo,Qr.config.isReservedTag=Do,Qr.config.isReservedAttr=vo,Qr.config.getTagNamespace=Mo,Qr.config.isUnknownElement=Fo,D(Qr.options.directives,La),D(Qr.options.components,Qa),Qr.prototype.__patch__=tt?Oa:L,Qr.prototype.$mount=function(t,e){return t=t&&tt?Uo(t):void 0,An(this,t,e)},tt&&setTimeout((function(){K.devtools&&dt&&dt.emit("init",Qr)}),0)}).call(this,n("c8ba"))},"499e":function(t,e,n){"use strict";function r(t,e){for(var n=[],r={},o=0;o<e.length;o++){var i=e[o],a=i[0],s=i[1],c=i[2],u=i[3],l={id:t+":"+o,css:s,media:c,sourceMap:u};r[a]?r[a].parts.push(l):n.push(r[a]={id:a,parts:[l]})}return n}n.r(e),n.d(e,"default",(function(){return v}));var o="undefined"!==typeof document;if("undefined"!==typeof DEBUG&&DEBUG&&!o)throw new Error("vue-style-loader cannot be used in a non-browser environment. Use { target: 'node' } in your Webpack config to indicate a server-rendering environment.");var i={},a=o&&(document.head||document.getElementsByTagName("head")[0]),s=null,c=0,u=!1,l=function(){},f=null,d="data-vue-ssr-id",p="undefined"!==typeof navigator&&/msie [6-9]\b/.test(navigator.userAgent.toLowerCase());function v(t,e,n,o){u=n,f=o||{};var a=r(t,e);return h(a),function(e){for(var n=[],o=0;o<a.length;o++){var s=a[o],c=i[s.id];c.refs--,n.push(c)}e?(a=r(t,e),h(a)):a=[];for(o=0;o<n.length;o++){c=n[o];if(0===c.refs){for(var u=0;u<c.parts.length;u++)c.parts[u]();delete i[c.id]}}}}function h(t){for(var e=0;e<t.length;e++){var n=t[e],r=i[n.id];if(r){r.refs++;for(var o=0;o<r.parts.length;o++)r.parts[o](n.parts[o]);for(;o<n.parts.length;o++)r.parts.push(_(n.parts[o]));r.parts.length>n.parts.length&&(r.parts.length=n.parts.length)}else{var a=[];for(o=0;o<n.parts.length;o++)a.push(_(n.parts[o]));i[n.id]={id:n.id,refs:1,parts:a}}}}function m(){var t=document.createElement("style");return t.type="text/css",a.appendChild(t),t}function _(t){var e,n,r=document.querySelector("style["+d+'~="'+t.id+'"]');if(r){if(u)return l;r.parentNode.removeChild(r)}if(p){var o=c++;r=s||(s=m()),e=g.bind(null,r,o,!1),n=g.bind(null,r,o,!0)}else r=m(),e=b.bind(null,r),n=function(){r.parentNode.removeChild(r)};return e(t),function(r){if(r){if(r.css===t.css&&r.media===t.media&&r.sourceMap===t.sourceMap)return;e(t=r)}else n()}}var y=function(){var t=[];return function(e,n){return t[e]=n,t.filter(Boolean).join("\n")}}();function g(t,e,n,r){var o=n?"":r.css;if(t.styleSheet)t.styleSheet.cssText=y(e,o);else{var i=document.createTextNode(o),a=t.childNodes;a[e]&&t.removeChild(a[e]),a.length?t.insertBefore(i,a[e]):t.appendChild(i)}}function b(t,e){var n=e.css,r=e.media,o=e.sourceMap;if(r&&t.setAttribute("media",r),f.ssrId&&t.setAttribute(d,e.id),o&&(n+="\n/*# sourceURL="+o.sources[0]+" */",n+="\n/*# sourceMappingURL=data:application/json;base64,"+btoa(unescape(encodeURIComponent(JSON.stringify(o))))+" */"),t.styleSheet)t.styleSheet.cssText=n;else{while(t.firstChild)t.removeChild(t.firstChild);t.appendChild(document.createTextNode(n))}}},c8ba:function(t,e){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(r){"object"===typeof window&&(n=window)}t.exports=n}}]);
+//# sourceMappingURL=chunk-vendors.20f7f886.js.map

dist/js/index.cbb15892.js

@@ -0,0 +1,2 @@
+(function(e){function n(n){for(var t,u,c=n[0],i=n[1],l=n[2],s=0,h=[];s<c.length;s++)u=c[s],Object.prototype.hasOwnProperty.call(o,u)&&o[u]&&h.push(o[u][0]),o[u]=0;for(t in i)Object.prototype.hasOwnProperty.call(i,t)&&(e[t]=i[t]);f&&f(n);while(h.length)h.shift()();return a.push.apply(a,l||[]),r()}function r(){for(var e,n=0;n<a.length;n++){for(var r=a[n],t=!0,u=1;u<r.length;u++){var i=r[u];0!==o[i]&&(t=!1)}t&&(a.splice(n--,1),e=c(c.s=r[0]))}return e}var t={},o={index:0},a=[];function u(e){return c.p+"js/"+({}[e]||e)+"."+{"chunk-ae402692":"003457bc","chunk-0c4e36c8":"95d70738","chunk-117382e0":"d47336d3","chunk-40965e1a":"74707226","chunk-04395031":"dbff2f6b","chunk-0cbfe13e":"73856287","chunk-2d0db258":"a4804a7a","chunk-2d0c53c7":"d24941b8","chunk-48b5b2a0":"3db5a0aa","chunk-a06ef50c":"1caef24f"}[e]+".js"}function c(n){if(t[n])return t[n].exports;var r=t[n]={i:n,l:!1,exports:{}};return e[n].call(r.exports,r,r.exports,c),r.l=!0,r.exports}c.e=function(e){var n=[],r=o[e];if(0!==r)if(r)n.push(r[2]);else{var t=new Promise((function(n,t){r=o[e]=[n,t]}));n.push(r[2]=t);var a,i=document.createElement("script");i.charset="utf-8",i.timeout=120,c.nc&&i.setAttribute("nonce",c.nc),i.src=u(e);var l=new Error;a=function(n){i.onerror=i.onload=null,clearTimeout(s);var r=o[e];if(0!==r){if(r){var t=n&&("load"===n.type?"missing":n.type),a=n&&n.target&&n.target.src;l.message="Loading chunk "+e+" failed.\n("+t+": "+a+")",l.name="ChunkLoadError",l.type=t,l.request=a,r[1](l)}o[e]=void 0}};var s=setTimeout((function(){a({type:"timeout",target:i})}),12e4);i.onerror=i.onload=a,document.head.appendChild(i)}return Promise.all(n)},c.m=e,c.c=t,c.d=function(e,n,r){c.o(e,n)||Object.defineProperty(e,n,{enumerable:!0,get:r})},c.r=function(e){"undefined"!==typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},c.t=function(e,n){if(1&n&&(e=c(e)),8&n)return e;if(4&n&&"object"===typeof e&&e&&e.__esModule)return e;var r=Object.create(null);if(c.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:e}),2&n&&"string"!=typeof e)for(var t in e)c.d(r,t,function(n){return e[n]}.bind(null,t));return r},c.n=function(e){var n=e&&e.__esModule?function(){return e["default"]}:function(){return e};return c.d(n,"a",n),n},c.o=function(e,n){return Object.prototype.hasOwnProperty.call(e,n)},c.p="",c.oe=function(e){throw console.error(e),e};var i=window["webpackJsonp"]=window["webpackJsonp"]||[],l=i.push.bind(i);i.push=n,i=i.slice();for(var s=0;s<i.length;s++)n(i[s]);var f=l;a.push([0,"chunk-vendors"]),r()})({0:function(e,n,r){e.exports=r("c7c3")},6786:function(e,n,r){"use strict";r("97cc")},"828f":function(e,n,r){var t=r("24fb");n=t(!1),n.push([e.i,"body{margin:0;overflow:hidden}",""]),e.exports=n},"97cc":function(e,n,r){var t=r("828f");t.__esModule&&(t=t.default),"string"===typeof t&&(t=[[e.i,t,""]]),t.locals&&(e.exports=t.locals);var o=r("499e").default;o("a0b5d278",t,!0,{sourceMap:!1,shadowMode:!1})},aa4a:function(e,n,r){var t={"./flex-engraver.vue":["e168","chunk-ae402692","chunk-0c4e36c8","chunk-117382e0"],"./playground.vue":["1140","chunk-ae402692","chunk-0c4e36c8","chunk-40965e1a","chunk-04395031"],"./profiler.vue":["5748","chunk-ae402692","chunk-40965e1a","chunk-0cbfe13e"]};function o(e){if(!r.o(t,e))return Promise.resolve().then((function(){var n=new Error("Cannot find module '"+e+"'");throw n.code="MODULE_NOT_FOUND",n}));var n=t[e],o=n[0];return Promise.all(n.slice(1).map(r.e)).then((function(){return r(o)}))}o.keys=function(){return Object.keys(t)},o.id="aa4a",e.exports=o},c7c3:function(e,n,r){"use strict";r.r(n);var t=r("2b0e"),o=function(){var e=this,n=e._self._c;return n("body",[e.view?n(e.view,{tag:"component"}):e._e()],1)},a=[];const u=["playground","profiler","flex-engraver"];u.forEach(e=>t["a"].component(e,()=>r("aa4a")(`./${e}.vue`)));var c={name:"lotus",data(){return{view:null}},mounted(){this.onHashChange(),window.onhashchange=()=>this.onHashChange()},methods:{onHashChange(){this.view=(location.hash.substr(1)||"playground").replace(/\?.*/,"")}}},i=c,l=(r("6786"),r("2877")),s=Object(l["a"])(i,o,a,!1,null,null,null),f=s.exports;new t["a"]({render:e=>e(f)}).$mount("body")}});
+//# sourceMappingURL=index.cbb15892.js.map

inc/DictArray.ts

@@ -0,0 +1,35 @@
+
+class DictArray extends Array {
+	constructor (jsonObj?: object) {
+		super();
+
+		if (jsonObj) {
+			console.assert(typeof jsonObj === "object", "invalid input type:", jsonObj);
+
+			if (Array.isArray(jsonObj))
+				Object.keys(jsonObj).forEach(index => this[index] = jsonObj[index]);
+			else
+				Object.entries(jsonObj).forEach(([key, value]) => this[key] = value);
+		}
+	}
+
+
+	toJSON () {
+		return Object.keys(this).reduce((dict, index) => (dict[index] = this[index], dict), {__prototype: "DictArray"});
+	}
+
+
+	clear () {
+		Object.keys(this).forEach(index => delete this[index]);
+		this.length = 0;
+	}
+
+
+	clone () {
+		return new DictArray(this);
+	}
+};
+
+
+
+export default DictArray;

inc/asyncCall.ts

@@ -0,0 +1,11 @@
+
+const asyncCall = (func, ...args): Promise<any> => new Promise((resolve, reject) => func(...args, (err, data) => {
+	if (err)
+		reject(err);
+	else
+		resolve(data);
+}));
+
+
+
+export default asyncCall;

inc/constants.ts

@@ -0,0 +1,38 @@
+
+const LILYPOND_VERSION = "2.20.0";
+
+
+const CM_TO_PX = 37.794;
+
+const LILY_TOP_MARGIN_DEFAULT = 0.5;
+const LILY_BOTTOM_MARGIN_DEFAULT = 0.6;
+const LILY_HORIZONTAL_MARGIN_DEFAULT = 1;
+const LILY_STAFF_SIZE_DEFAULT = 20;
+
+//const SYSTEM_SYSTEM_SPACING = 0.08;
+
+const STAFF_HEAD_DEDUCTION = 0.06;	// extra width augment when system wrap added, cm per staff size
+
+
+const SVG_DTD = `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"
+  [<!ENTITY quot "&#34;">  <!ENTITY amp "&#38;">  <!ENTITY apos "&#39;">  <!ENTITY lt "&#60;">  <!ENTITY gt "&#62;">  <!ENTITY nbsp "&#160;">  <!ENTITY iexcl "&#161;">  <!ENTITY cent "&#162;">  <!ENTITY pound "&#163;">  <!ENTITY curren "&#164;">  <!ENTITY yen "&#165;">  <!ENTITY brvbar "&#166;">  <!ENTITY sect "&#167;">  <!ENTITY uml "&#168;">  <!ENTITY copy "&#169;">  <!ENTITY ordf "&#170;">  <!ENTITY laquo "&#171;">  <!ENTITY not "&#172;">  <!ENTITY shy "&#173;">  <!ENTITY reg "&#174;">  <!ENTITY macr "&#175;">  <!ENTITY deg "&#176;">  <!ENTITY plusmn "&#177;">  <!ENTITY sup2 "&#178;">  <!ENTITY sup3 "&#179;">  <!ENTITY acute "&#180;">  <!ENTITY micro "&#181;">  <!ENTITY para "&#182;">  <!ENTITY middot "&#183;">  <!ENTITY cedil "&#184;">  <!ENTITY sup1 "&#185;">  <!ENTITY ordm "&#186;">  <!ENTITY raquo "&#187;">  <!ENTITY frac14 "&#188;">  <!ENTITY frac12 "&#189;">  <!ENTITY frac34 "&#190;">  <!ENTITY iquest "&#191;">  <!ENTITY Agrave "&#192;">  <!ENTITY Aacute "&#193;">  <!ENTITY Acirc "&#194;">  <!ENTITY Atilde "&#195;">  <!ENTITY Auml "&#196;">  <!ENTITY Aring "&#197;">  <!ENTITY AElig "&#198;">  <!ENTITY Ccedil "&#199;">  <!ENTITY Egrave "&#200;">  <!ENTITY Eacute "&#201;">  <!ENTITY Ecirc "&#202;">  <!ENTITY Euml "&#203;">  <!ENTITY Igrave "&#204;">  <!ENTITY Iacute "&#205;">  <!ENTITY Icirc "&#206;">  <!ENTITY Iuml "&#207;">  <!ENTITY ETH "&#208;">  <!ENTITY Ntilde "&#209;">  <!ENTITY Ograve "&#210;">  <!ENTITY Oacute "&#211;">  <!ENTITY Ocirc "&#212;">  <!ENTITY Otilde "&#213;">  <!ENTITY Ouml "&#214;">  <!ENTITY times "&#215;">  <!ENTITY Oslash "&#216;">  <!ENTITY Ugrave "&#217;">  <!ENTITY Uacute "&#218;">  <!ENTITY Ucirc "&#219;">  <!ENTITY Uuml "&#220;">  <!ENTITY Yacute "&#221;">  <!ENTITY THORN "&#222;">  <!ENTITY szlig "&#223;">  <!ENTITY agrave "&#224;">  <!ENTITY aacute "&#225;">  <!ENTITY acirc "&#226;">  <!ENTITY atilde "&#227;">  <!ENTITY auml "&#228;">  <!ENTITY aring "&#229;">  <!ENTITY aelig "&#230;">  <!ENTITY ccedil "&#231;">  <!ENTITY egrave "&#232;">  <!ENTITY eacute "&#233;">  <!ENTITY ecirc "&#234;">  <!ENTITY euml "&#235;">  <!ENTITY igrave "&#236;">  <!ENTITY iacute "&#237;">  <!ENTITY icirc "&#238;">  <!ENTITY iuml "&#239;">  <!ENTITY eth "&#240;">  <!ENTITY ntilde "&#241;">  <!ENTITY ograve "&#242;">  <!ENTITY oacute "&#243;">  <!ENTITY ocirc "&#244;">  <!ENTITY otilde "&#245;">  <!ENTITY ouml "&#246;">  <!ENTITY divide "&#247;">  <!ENTITY oslash "&#248;">  <!ENTITY ugrave "&#249;">  <!ENTITY uacute "&#250;">  <!ENTITY ucirc "&#251;">  <!ENTITY uuml "&#252;">  <!ENTITY yacute "&#253;">  <!ENTITY thorn "&#254;">  <!ENTITY yuml "&#255;">  <!ENTITY OElig "&#338;">  <!ENTITY oelig "&#339;">  <!ENTITY Scaron "&#352;">  <!ENTITY scaron "&#353;">  <!ENTITY Yuml "&#376;">  <!ENTITY fnof "&#402;">  <!ENTITY circ "&#710;">  <!ENTITY tilde "&#732;">  <!ENTITY Alpha "&#913;">  <!ENTITY Beta "&#914;">  <!ENTITY Gamma "&#915;">  <!ENTITY Delta "&#916;">  <!ENTITY Epsilon "&#917;">  <!ENTITY Zeta "&#918;">  <!ENTITY Eta "&#919;">  <!ENTITY Theta "&#920;">  <!ENTITY Iota "&#921;">  <!ENTITY Kappa "&#922;">  <!ENTITY Lambda "&#923;">  <!ENTITY Mu "&#924;">  <!ENTITY Nu "&#925;">  <!ENTITY Xi "&#926;">  <!ENTITY Omicron "&#927;">  <!ENTITY Pi "&#928;">  <!ENTITY Rho "&#929;">  <!ENTITY Sigma "&#931;">  <!ENTITY Tau "&#932;">  <!ENTITY Upsilon "&#933;">  <!ENTITY Phi "&#934;">  <!ENTITY Chi "&#935;">  <!ENTITY Psi "&#936;">  <!ENTITY Omega "&#937;">  <!ENTITY alpha "&#945;">  <!ENTITY beta "&#946;">  <!ENTITY gamma "&#947;">  <!ENTITY delta "&#948;">  <!ENTITY epsilon "&#949;">  <!ENTITY zeta "&#950;">  <!ENTITY eta "&#951;">  <!ENTITY theta "&#952;">  <!ENTITY iota "&#953;">  <!ENTITY kappa "&#954;">  <!ENTITY lambda "&#955;">  <!ENTITY mu "&#956;">  <!ENTITY nu "&#957;">  <!ENTITY xi "&#958;">  <!ENTITY omicron "&#959;">  <!ENTITY pi "&#960;">  <!ENTITY rho "&#961;">  <!ENTITY sigmaf "&#962;">  <!ENTITY sigma "&#963;">  <!ENTITY tau "&#964;">  <!ENTITY upsilon "&#965;">  <!ENTITY phi "&#966;">  <!ENTITY chi "&#967;">  <!ENTITY psi "&#968;">  <!ENTITY omega "&#969;">  <!ENTITY thetasym "&#977;">  <!ENTITY upsih "&#978;">  <!ENTITY piv "&#982;">  <!ENTITY ensp "&#8194;">  <!ENTITY emsp "&#8195;">  <!ENTITY thinsp "&#8201;">  <!ENTITY zwnj "&#8204;">  <!ENTITY zwj "&#8205;">  <!ENTITY lrm "&#8206;">  <!ENTITY rlm "&#8207;">  <!ENTITY ndash "&#8211;">  <!ENTITY mdash "&#8212;">  <!ENTITY lsquo "&#8216;">  <!ENTITY rsquo "&#8217;">  <!ENTITY sbquo "&#8218;">  <!ENTITY ldquo "&#8220;">  <!ENTITY rdquo "&#8221;">  <!ENTITY bdquo "&#8222;">  <!ENTITY dagger "&#8224;">  <!ENTITY Dagger "&#8225;">  <!ENTITY bull "&#8226;">  <!ENTITY hellip "&#8230;">  <!ENTITY permil "&#8240;">  <!ENTITY prime "&#8242;">  <!ENTITY Prime "&#8243;">  <!ENTITY lsaquo "&#8249;">  <!ENTITY rsaquo "&#8250;">  <!ENTITY oline "&#8254;">  <!ENTITY frasl "&#8260;">  <!ENTITY euro "&#8364;">  <!ENTITY image "&#8465;">  <!ENTITY weierp "&#8472;">  <!ENTITY real "&#8476;">  <!ENTITY trade "&#8482;">  <!ENTITY alefsym "&#8501;">  <!ENTITY larr "&#8592;">  <!ENTITY uarr "&#8593;">  <!ENTITY rarr "&#8594;">  <!ENTITY darr "&#8595;">  <!ENTITY harr "&#8596;">  <!ENTITY crarr "&#8629;">  <!ENTITY lArr "&#8656;">  <!ENTITY uArr "&#8657;">  <!ENTITY rArr "&#8658;">  <!ENTITY dArr "&#8659;">  <!ENTITY hArr "&#8660;">  <!ENTITY forall "&#8704;">  <!ENTITY part "&#8706;">  <!ENTITY exist "&#8707;">  <!ENTITY empty "&#8709;">  <!ENTITY nabla "&#8711;">  <!ENTITY isin "&#8712;">  <!ENTITY notin "&#8713;">  <!ENTITY ni "&#8715;">  <!ENTITY prod "&#8719;">  <!ENTITY sum "&#8721;">  <!ENTITY minus "&#8722;">  <!ENTITY lowast "&#8727;">  <!ENTITY radic "&#8730;">  <!ENTITY prop "&#8733;">  <!ENTITY infin "&#8734;">  <!ENTITY ang "&#8736;">  <!ENTITY and "&#8743;">  <!ENTITY or "&#8744;">  <!ENTITY cap "&#8745;">  <!ENTITY cup "&#8746;">  <!ENTITY int "&#8747;">  <!ENTITY there4 "&#8756;">  <!ENTITY sim "&#8764;">  <!ENTITY cong "&#8773;">  <!ENTITY asymp "&#8776;">  <!ENTITY ne "&#8800;">  <!ENTITY equiv "&#8801;">  <!ENTITY le "&#8804;">  <!ENTITY ge "&#8805;">  <!ENTITY sub "&#8834;">  <!ENTITY sup "&#8835;">  <!ENTITY nsub "&#8836;">  <!ENTITY sube "&#8838;">  <!ENTITY supe "&#8839;">  <!ENTITY oplus "&#8853;">  <!ENTITY otimes "&#8855;">  <!ENTITY perp "&#8869;">  <!ENTITY sdot "&#8901;">  <!ENTITY lceil "&#8968;">  <!ENTITY rceil "&#8969;">  <!ENTITY lfloor "&#8970;">  <!ENTITY rfloor "&#8971;">  <!ENTITY lang "&#9001;">  <!ENTITY rang "&#9002;">  <!ENTITY loz "&#9674;">  <!ENTITY spades "&#9824;">  <!ENTITY clubs "&#9827;">  <!ENTITY hearts "&#9829;">  <!ENTITY diams "&#9830;">]>
+`;
+
+
+
+export {
+	LILYPOND_VERSION,
+
+	CM_TO_PX,
+
+	LILY_TOP_MARGIN_DEFAULT,
+	LILY_BOTTOM_MARGIN_DEFAULT,
+	LILY_HORIZONTAL_MARGIN_DEFAULT,
+	LILY_STAFF_SIZE_DEFAULT,
+	//SYSTEM_SYSTEM_SPACING,
+
+	STAFF_HEAD_DEDUCTION,
+
+	SVG_DTD,
+};

inc/domUtils.ts

@@ -0,0 +1,49 @@
+
+const traverse = (node, handle) => {
+	handle(node);
+
+	if (node.childNodes) {
+		for (let i = 0; i < node.childNodes.length; ++i)
+			traverse(node.childNodes[i], handle);
+	}
+};
+
+
+const childrenWithTag = (node: any, tagName: string): any[] => {
+	const children = Array.from(node.childNodes);
+	return children.filter((node: any) => node.tagName === tagName);
+};
+
+
+const hasChildrenWithTag = (node: any, tagName: string): boolean => {
+	const children = Array.from(node.childNodes);
+	return children.some((node: any) => node.tagName === tagName);
+};
+
+
+const findPreviousSibling = (node: any, tagName: string): any => {
+	let sibling = node.previousSibling;
+	while (sibling && sibling.tagName !== tagName)
+		sibling = sibling.previousSibling;
+
+	return sibling;
+};
+
+
+const findNextSibling = (node: any, tagName: string): any => {
+	let sibling = node.nextSibling;
+	while (sibling && sibling.tagName !== tagName)
+		sibling = sibling.nextSibling;
+
+	return sibling;
+};
+
+
+
+export {
+	traverse,
+	childrenWithTag,
+	hasChildrenWithTag,
+	findPreviousSibling,
+	findNextSibling,
+};

inc/jisonWrapper.ts

@@ -0,0 +1,34 @@
+
+import jison from "jison";
+
+
+
+export class Parser {
+	parser: any;
+
+
+	constructor (grammar: string) {
+		// mute jison logs during grammar loading
+		const logs = [];
+		jison.print = log => logs.push(log);
+
+		this.parser = jison.Parser(grammar);
+		if (!this.parser) {
+			console.warn("jison logs:", logs);
+			throw new Error("jison parser loading failed");
+		}
+
+		jison.print = (...args) => console.log("[JISON]", ...args);
+	}
+
+
+	parse (source: string): object {
+		//console.log("parse:", source.length);
+		return this.parser.parse(source);
+	}
+
+
+	generate (): string {
+		return this.parser.generate();
+	}
+};

inc/jsonRecovery.ts

@@ -0,0 +1,41 @@
+
+
+const recoverJSON = (json: string | object, classDict) => {
+	if (typeof json === "object")
+		json = JSON.stringify(json);
+
+	return JSON.parse(json, (_, value) => {
+		if (value && (typeof value === "object") && value.__prototype) {
+			const Class = classDict[value.__prototype];
+			if (Class) {
+				const {__prototype, ...fields} = value;
+				return new Class(fields);
+			}
+		}
+
+		return value;
+	});
+};
+
+
+class SimpleClass {
+	constructor (data?: object) {
+		if (data)
+			Object.assign(this, data);
+	}
+
+
+	toJSON () {
+		return {
+			__prototype: (this.constructor as any).className,
+			...this,
+		};
+	}
+};
+
+
+
+export {
+	recoverJSON,
+	SimpleClass,
+};

inc/lilyNotation/fuzzyMatch.ts

@@ -0,0 +1,125 @@
+
+// eslint-disable-next-line
+import {MusicNotation} from "@k-l-lambda/music-widgets";
+
+
+
+interface Note {
+	index: number;
+	pitch: number;
+	softIndex: number;
+	baseCsi?: number;
+};
+
+
+const notePitchDistance = (n1: Note, n2: Note): number => {
+	let differ = Math.abs(n1.pitch - n2.pitch);
+	if (differ > 7)
+		differ -= 11.5;
+
+	return differ * 2;
+};
+
+
+const fuzzyMatchNotes = (path: number[], cnotes: Note[], snotes: Note[], pitchTolerance: number, offsetTolerance = 2): {fixed: number, matched: number} => {
+	const candidates: {[key: number]: {si: number, distance: number}} = {};
+
+	const matched = snotes.reduce((count, snote) => {
+		const pcan = cnotes.filter(cnote => notePitchDistance(cnote, snote) <= pitchTolerance
+			&& Math.abs(snote.baseCsi - cnote.softIndex) < offsetTolerance)
+			.sort((n1, n2) => Math.abs(snote.baseCsi - n1.softIndex) - Math.abs(snote.baseCsi - n2.softIndex));
+
+		if (pcan.length) {
+			const bestDistance = notePitchDistance(pcan[0], snote);
+			const last = candidates[pcan[0].index];
+			if (!last || bestDistance < last.distance)
+				candidates[pcan[0].index] = {si: snote.index, distance: bestDistance};
+
+			++count;
+		}
+
+		return count;
+	}, 0);
+
+	const fixed = Object.entries(candidates).map(([ci, {si}]) => {
+		path[si] = Number(ci);
+
+		return [si, Number(ci)];
+	});
+	//console.debug("fuzzyMatch.fixed:", fixed.map(pair => pair.join()));
+
+	return {fixed: fixed.length, matched};
+};
+
+
+const fuzzyMatchNotations = (path: number[], criterion: MusicNotation.NotationData, sample: MusicNotation.NotationData, {pitchToleranceMax = 4} = {}) => {
+	// unmatch overlapped indices
+	const overlapped = new Set();
+	path.reduce((set, ci) => {
+		if (ci >= 0) {
+			if (set.has(ci))
+				overlapped.add(ci);
+			else
+				set.add(ci);
+		}
+
+		return set;
+	}, new Set());
+	//console.debug("overlapped:", overlapped, [...path]);
+	path.forEach((ci, si) => {
+		if (overlapped.has(ci))
+			path[si] = -1;
+	});
+
+	// assign base offset on sample notes
+	let offset = null;
+	for (let i = 0; i < sample.notes.length; ++i) {
+		const note = sample.notes[i];
+		const ci = path[i];
+
+		if (ci < 0)
+			(note as any).baseOffset = offset;
+		else
+			offset = note.softIndex - criterion.notes[ci].softIndex;
+	}
+	for (let i = sample.notes.length - 1; i >= 0; --i) {
+		const note = sample.notes[i];
+		const ci = path[i];
+
+		if (ci < 0) {
+			const lastOffset = (note as any).baseOffset;
+			(note as any).baseOffset = Number.isFinite(lastOffset) ? (lastOffset + offset) / 2 : offset;
+		}
+		else
+			offset = note.softIndex - criterion.notes[ci].softIndex;
+	}
+
+	let pitchTolerance = 0;
+	while (true) {
+		const cnotes = criterion.notes.filter(note => !path.some(ci => ci === note.index)).map(note => ({index: note.index, pitch: note.pitch, softIndex: note.softIndex}));
+		const snotes = sample.notes.filter(note => path[note.index] < 0 && Number.isFinite((note as any).baseOffset))
+			.map(note => ({index: note.index, pitch: note.pitch, softIndex: note.softIndex, baseCsi: note.softIndex - (note as any).baseOffset}));
+
+		//console.debug("fuzzyMatch.notes:", cnotes.map(note => note.index), snotes.map(note => note.index));
+
+		if (!cnotes.length || !snotes.length)
+			break;
+
+		const {fixed, matched} = fuzzyMatchNotes(path, cnotes, snotes, pitchTolerance);
+		if (matched)
+			console.debug("fuzzyMatch.pass:", `c:${cnotes.length}, s:${snotes.length},`, pitchTolerance, `${fixed}/${matched}`);
+
+		if (fixed >= matched) {
+			++pitchTolerance;
+			if (pitchTolerance > pitchToleranceMax)
+				break;
+		}
+	}
+	//console.debug("fuzzyMatch.path:", path);
+};
+
+
+
+export {
+	fuzzyMatchNotations,
+};

inc/lilyNotation/implicitType.ts

@@ -0,0 +1,16 @@
+
+// implicit note (from expressive marks) types
+enum ImplicitType {
+	None = 0,
+
+	Mordent = "mordent",
+	Prall = "prall",
+	Turn = "turn",
+	Trill = "trill",
+	Tremolo = "tremolo",
+	Arpeggio = "arpeggio",
+};
+
+
+
+export default ImplicitType;

inc/lilyNotation/index.ts

@@ -0,0 +1,27 @@
+
+import {Note, Notation, assignNotationEventsIds} from "./notation";
+import {fuzzyMatchNotations} from "./fuzzyMatch";
+import {matchWithMIDI, matchWithExactMIDI} from "./matcher";
+import Scheduler from "./scheduler";
+import ImplicitType from "./implicitType";
+import * as measureLayout from "../measureLayout";
+import {LayoutType} from "../measureLayout";
+
+
+
+const {...MLayoutClasses} = measureLayout;
+
+
+
+export {
+	Note,
+	Notation,
+	fuzzyMatchNotations,
+	assignNotationEventsIds,
+	matchWithMIDI,
+	matchWithExactMIDI,
+	Scheduler,
+	ImplicitType,
+	LayoutType,
+	MLayoutClasses,
+};

inc/lilyNotation/matcher.ts

@@ -0,0 +1,191 @@
+
+import {MusicNotation, Matcher} from "@k-l-lambda/music-widgets";
+import {MIDI} from "@k-l-lambda/music-widgets";
+
+import {WHOLE_DURATION_MAGNITUDE} from "../lilyParser/utils";
+import {Notation} from "./notation";
+import ImplicitType from "./implicitType";
+
+
+
+export interface MatcherResult {
+	criterion: MusicNotation.NotationData,
+	sample: MusicNotation.NotationData,
+	path: number[],	// S to C
+	trackMap?: number[],	// S to C
+};
+
+
+const matchWithMIDI = async (lilyNotation: Notation, target: MIDI.MidiData): Promise<MatcherResult> => {
+	const midiTickFactor = (WHOLE_DURATION_MAGNITUDE / 4) / target.header.ticksPerBeat;
+
+	const midiNotation = MusicNotation.Notation.parseMidi(target);
+
+	const criterion = lilyNotation.toPerformingNotation();
+
+	Matcher.genNotationContext(criterion, {softIndexFactor: 1e3});
+	Matcher.genNotationContext(midiNotation, {softIndexFactor: midiTickFactor * 1e3});
+	//console.debug("notations:", criterion, midiNotation);
+
+	for (const note of midiNotation.notes)
+		Matcher.makeMatchNodes(note, criterion);
+
+	const navigator = await Matcher.runNavigation(criterion, midiNotation);
+	const path = navigator.path();
+
+	const matcher = {criterion, sample: midiNotation, path};
+	lilyNotation.assignMatcher(matcher);
+
+	return matcher;
+};
+
+
+const IMPLICIT_PITCH_BIAS = {
+	[ImplicitType.Mordent]: [0, -1, -2],
+	[ImplicitType.Prall]: [0, 1, 2],
+	[ImplicitType.Turn]: [-2, -1, 0, 1, 2],
+	[ImplicitType.Trill]: [0, 1, 2],
+};
+
+
+const alignNotationTicks = (source: MusicNotation.Notation, criterion: MusicNotation.Notation, {midiTrackTickBias}: {midiTrackTickBias?: number[]}) => {
+	const midiTickFactor = criterion.ticksPerBeat / source.ticksPerBeat;
+
+	source.ticksPerBeat = criterion.ticksPerBeat;
+	source.notes.forEach(note => {
+		note.startTick *= midiTickFactor;
+		note.endTick *= midiTickFactor;
+
+		const bias = midiTrackTickBias && midiTrackTickBias[note.track];
+		if (bias) {
+			note.startTick += bias;
+			note.endTick += bias;
+		}
+	});
+
+	source.events.forEach(event => {
+		event.ticks *= midiTickFactor;
+
+		const bias = midiTrackTickBias && midiTrackTickBias[event.track];
+		if (bias)
+			event.ticks += bias;
+	});
+	source.events.sort((e1, e2) => e1.ticks - e2.ticks);
+};
+
+
+const matchWithExactMIDI = async (lilyNotation: Notation, target: MIDI.MidiData): Promise<MatcherResult> => {
+	const criterion = lilyNotation.toPerformingNotation();
+
+	const trackTickBiasMap = lilyNotation.trackTickBias;
+	const targetTrackNames = target.tracks.map(events => {
+		const nameEvent = events.find(event => event.subtype === "trackName");
+		return nameEvent ? nameEvent.text : null;
+	});
+	const trackIndexC2S = lilyNotation.trackNames.map(name => targetTrackNames.indexOf(name));
+	//if (trackIndexC2S.includes(-1))
+	//	console.debug("mismatched track found:", trackIndexC2S, lilyNotation.trackNames, targetTrackNames);
+
+	const midiTrackTickBias = targetTrackNames.map(name => name ? (trackTickBiasMap[name] || 0) : 0);
+	//console.log("midiTrackTickBias:", midiTrackTickBias);
+
+	const midiNotation = MusicNotation.Notation.parseMidi(target, {fixOverlap: false});
+	alignNotationTicks(midiNotation, criterion, {midiTrackTickBias});
+
+	// 1st pass: ordinary notes exact matching
+	const noteKey = note => `${note.track}|${Math.round(note.startTick)}|${note.pitch}`;
+
+	const snoteMap: {[key: string]: MusicNotation.Note} = {};
+	midiNotation.notes.forEach(note => {
+		snoteMap[noteKey(note)] = note;
+	});
+
+	const path = Array(midiNotation.notes.length).fill(-1);
+
+	const restCNotes = [];
+	criterion.notes.forEach(note => {
+		const implicit = !!(note as any).implicitType;
+
+		const key = noteKey({...note, track: trackIndexC2S[note.track - 1]});
+		const sn = snoteMap[key];
+		if (sn) {
+			path[sn.index] = note.index;
+			delete snoteMap[key];
+
+			if (!implicit)
+				return;
+		}
+
+		restCNotes.push(note);
+	});
+
+	// 2nd pass: implicit notes matching
+	const restCNotes2 = [];
+	const restSNotes = Object.values(snoteMap);
+	restCNotes.forEach(note => {
+		if (note.implicitType) {
+			const pbs = IMPLICIT_PITCH_BIAS[note.implicitType];
+			if (pbs) {
+				const matches = restSNotes.filter(sn => {
+					const tick = Math.round(sn.startTick);
+					const pb = sn.pitch - note.pitch;
+					return tick >= note.startTick && tick <= note.endTick && pbs.includes(pb);
+				});
+
+				if (matches.length) {
+					matches.forEach(sn => {
+						path[sn.index] = note.index;
+						delete snoteMap[noteKey(sn)];
+					});
+
+					return;
+				}
+			}
+		}
+
+		restCNotes2.push(note);
+	});
+
+	// 3rd pass: rest fuzzy matching
+	const restCNotes3 = [];
+	restCNotes2.forEach(note => {
+		const sn = restSNotes.find(sn => sn.pitch === note.pitch && Math.abs(sn.startTick - note.startTick) < 4);
+		if (sn) {
+			path[sn.index] = note.index;
+			delete snoteMap[noteKey(sn)];
+		}
+		else
+			restCNotes3.push(note);
+	});
+
+	// 4th pass: nearest matching
+	const restSNotes3 = Object.values(snoteMap);
+	//console.log("restCNotes3:", restCNotes3.map(n => n.index));
+	//console.log("restSNotes3:", restSNotes3.map(n => n.index));
+	restSNotes3.forEach(note => {
+		const cn = restCNotes3.reduce((best, cn) => {
+			if (cn.pitch === note.pitch) {
+				if (!best || Math.abs(cn.startTick - note.startTick) < Math.abs(best.startTick - note.startTick))
+					return cn;
+			}
+
+			return best;
+		}, null);
+		if (cn)
+			path[note.index] = cn.index;
+	});
+
+	const trackMap = Object.entries(trackIndexC2S).reduce((map, [ct, st]) => ((st >= 0 && (map[st] = Number(ct) + 1)), map), []);
+
+	const matcher = {criterion, sample: midiNotation, path, trackMap};
+	lilyNotation.assignMatcher(matcher);
+
+	return matcher;
+};
+
+
+
+export {
+	matchWithMIDI,
+	matchWithExactMIDI,
+};

inc/lilyNotation/notation.ts

@@ -0,0 +1,675 @@
+
+import {MusicNotation, MIDI} from "@k-l-lambda/music-widgets";
+
+import {WHOLE_DURATION_MAGNITUDE} from "../lilyParser/utils";
+import {PitchContextTable} from "../pitchContext";
+import {MatcherResult} from "./matcher";
+import {MeasureLayout, LayoutType} from "../measureLayout";
+import ImplicitType from "./implicitType";
+import npmPackage from "../../package.json";
+import pick from "../pick";
+
+
+
+const TICKS_PER_BEAT = WHOLE_DURATION_MAGNITUDE / 4;
+
+const ARPEGGIO_REFERENCE_DURATION = 240;
+
+// import WHOLE_DURATION_MAGNITUDE from "../lilyParser" may result in null error in nodejs
+console.assert(Number.isFinite(TICKS_PER_BEAT), "TICKS_PER_BEAT is invalid:", TICKS_PER_BEAT);
+
+
+export interface ChordPosition {
+	index: number;
+	count: number;
+};
+
+
+interface StaffNoteProperties {
+	rest: boolean;
+	tied: boolean;
+	overlapped: boolean;
+	implicitType: ImplicitType;
+	afterGrace: boolean;
+	chordPosition: ChordPosition;
+	division: number;
+
+	contextIndex: number;
+	staffTrack: number;
+};
+
+
+export interface Note extends MusicNotation.Note, Partial<StaffNoteProperties> {
+	id: string;
+	measure: number;
+	endTick: number;
+	outMeasure?: boolean;
+};
+
+
+interface SubNote {
+	startTick: number;
+	endTick: number;
+	pitch: number;
+	velocity?: number;
+};
+
+
+interface MeasureNote extends Partial<StaffNoteProperties> {
+	tick: number;
+	pitch: number;
+	duration: number;
+	chordPosition: ChordPosition;
+
+	track: number;
+	channel: number;
+	id: string;
+	ids: string[];
+
+	subNotes: SubNote[];
+};
+
+
+interface MeasureEvent {
+	data: any;
+	track: number;
+	ticks?: number;
+};
+
+
+interface Measure {
+	tick: number;
+	duration: number;
+
+	notes: MeasureNote[];
+	events?: MeasureEvent[];
+};
+
+
+interface PerformOptions {
+	withRestTied?: boolean;
+};
+
+
+/*interface NotationData {
+	pitchContextGroup: PitchContextTable[];
+	measures: Measure[];
+};*/
+
+
+const EXTRA_NOTE_FIELDS = ["rest", "tied", "overlapped", "implicitType", "afterGrace", "contextIndex", "staffTrack", "chordPosition", "division"];
+const COMMON_NOTE_FIELDS = ["id", "ids", "pitch", "velocity", "track", "channel", ...EXTRA_NOTE_FIELDS];
+
+
+export class Notation {
+	pitchContextGroup: PitchContextTable[];
+	measureLayout: MeasureLayout;
+	measures: Measure[];
+
+	trackNames: string[];
+	idTrackMap: {[key: string]: number};
+
+	ripe: boolean = false;
+
+
+	static fromAbsoluteNotes (notes: Note[], measureHeads: number[], data?: Partial<Notation>): Notation {
+		const notation = new Notation(data);
+
+		notation.measures = Array(measureHeads.length).fill(null).map((__, i) => {
+			const tick = measureHeads[i];
+			const duration = measureHeads[i + 1] ? (measureHeads[i + 1] - tick) : 0;
+
+			const mnotes = notes.filter(note => note.measure === i + 1).map(note => ({
+				tick: note.startTick - tick,
+				duration: note.endTick - note.startTick,
+				...pick(note, COMMON_NOTE_FIELDS),
+				subNotes: [],
+			} as MeasureNote));
+
+			// reduce note data size
+			mnotes.forEach(mn => ["rest", "tied", "implicitType", "afterGrace"].forEach(field => {
+				if (!mn[field])
+					delete mn[field];
+			}));
+
+			return {
+				tick,
+				duration,
+				notes: mnotes,
+			};
+		});
+
+		notation.idTrackMap = notes.reduce((map, note) => {
+			if (note.id)
+				map[note.id] = note.track;
+
+			return map;
+		}, {});
+
+		return notation;
+	}
+
+
+	static performAbsoluteNotes (abNotes: Note[], {withRestTied = false}: PerformOptions = {}): MusicNotation.Note[] {
+		const notes = abNotes.filter(note => (withRestTied || (!note.rest && !note.tied)) && !note.overlapped).map(note => ({
+			measure: note.measure,
+			channel: note.channel,
+			track: note.track,
+			start: note.start,
+			startTick: note.startTick,
+			endTick: note.endTick,
+			pitch: note.pitch,
+			duration: note.duration,
+			velocity: note.velocity || 127,
+			id: note.id,
+			ids: note.ids,
+			staffTrack: note.staffTrack,
+			contextIndex: note.contextIndex,
+			implicitType: note.implicitType,
+			chordPosition: note.chordPosition,
+			outMeasure: note.outMeasure,
+		}));
+
+		const noteMap = notes.reduce((map, note) => {
+			const key = `${note.channel}|${note.start}|${note.pitch}`;
+			const priorNote = map[key];
+			if (priorNote)
+				priorNote.ids.push(...note.ids);
+			else
+				map[key] = note;
+	
+			return map;
+		}, {});
+
+		return Object.values(noteMap);
+	}
+
+
+	constructor (data?: Partial<Notation>) {
+		if (data)
+			Object.assign(this, data);
+	}
+
+
+	get ordinaryMeasureIndices (): number[] {
+		if (this.measureLayout)
+			return this.measureLayout.serialize(LayoutType.Ordinary);
+
+		return Array(this.measures.length).fill(null).map((_, i) => i + 1);
+	}
+
+
+	// In Lilypond 2.20.0, minus tick value at the head of a track result in MIDI event time bias,
+	//	So store the bias values to correct MIDI time from lilyond.
+	get trackTickBias (): {[key: string]: number} {
+		const headMeasure = this.measures[0];
+		return this.trackNames.reduce((map, name, track) => {
+			map[name] = 0;
+			if (headMeasure) {
+				const note = headMeasure.notes.find(note => note.track === track);
+				if (note)
+					map[name] = Math.min(note.tick, 0);
+			}
+
+			return map;
+		}, {});
+	}
+
+
+	get idSet (): Set<string> {
+		return this.measures.reduce((set, measure) =>
+			(measure.notes.filter(note => !note.rest).forEach(note => note.ids.forEach(id => set.add(id))), set), new Set<string>());
+	}
+
+
+	toJSON () {
+		return {
+			__prototype: "LilyNotation",
+			pitchContextGroup: this.pitchContextGroup,
+			measureLayout: this.measureLayout,
+			measures: this.measures,
+			idTrackMap: this.idTrackMap,
+			trackNames: this.trackNames,
+			ripe: this.ripe,
+		};
+	}
+
+
+	toAbsoluteNotes (measureIndices: number[] = this.ordinaryMeasureIndices): Note[] {
+		let measureTick = 0;
+		const measureNotes: Note[][] = measureIndices.map(index => {
+			const measure = this.measures[index - 1];
+			console.assert(!!measure, "invalid measure index:", index, this.measures.length);
+
+			const notes = measure.notes.map(mnote => {
+				const outMeasure = mnote.tick < 0 || mnote.tick >= measure.duration;
+
+				return {
+					startTick: measureTick + mnote.tick,
+					endTick: measureTick + mnote.tick + mnote.duration,
+					start: measureTick + mnote.tick,
+					duration: mnote.duration,
+					measure: index,
+					outMeasure,
+					...pick(mnote, COMMON_NOTE_FIELDS),
+				} as Note;
+			});
+
+			measureTick += measure.duration;
+
+			return notes;
+		});
+
+		return [].concat(...measureNotes);
+	}
+
+
+	getMeasureIndices (type: LayoutType) {
+		return this.measureLayout.serialize(type);
+	}
+
+
+	toPerformingNotation (measureIndices: number[] = this.ordinaryMeasureIndices, options: PerformOptions = {}): MusicNotation.Notation {
+		//console.debug("toPerformingNotation:", this, measureIndices);
+		const abNotes = this.toAbsoluteNotes(measureIndices);
+		const notes = Notation.performAbsoluteNotes(abNotes, options);
+
+		//const lastNote = notes[notes.length - 1];
+		const endTime = Math.max(...notes.map(note => note.start + note.duration));
+
+		const endTick = measureIndices.reduce((tick, index) => tick + this.measures[index - 1].duration, 0);
+
+		const notation = new MusicNotation.Notation({
+			ticksPerBeat: TICKS_PER_BEAT,
+			meta: {},
+			tempos: [],	// TODO
+			channels: [notes],
+			endTime,
+			endTick,
+		});
+
+		return notation;
+	}
+
+
+	toPerformingMIDI (measureIndices: number[], {trackList}: {trackList?: boolean[]} = {}): MIDI.MidiData & {zeroTick: number} {
+		if (!measureIndices.length)
+			return null;
+
+		// to avoid begin minus tick
+		const zeroTick = -Math.min(0,
+			...(this.measures[0] ? this.measures[0].events.map((e) => e.ticks) : []),
+			...(this.measures[0] ? this.measures[0].notes.map((note) => note.tick) : []));
+
+		let measureTick = zeroTick;
+		const measureEvents: MeasureEvent[][] = measureIndices.map(index => {
+			const measure = this.measures[index - 1];
+			console.assert(!!measure, "invalid measure index:", index, this.measures.length);
+
+			const events = measure.events.map(mevent => ({
+				ticks: measureTick + mevent.ticks,
+				track: mevent.track,
+				data: {
+					...mevent.data,
+					measure: index,
+				},
+			}));
+
+			measureTick += measure.duration;
+
+			return events;
+		});
+
+		interface MidiEvent extends MIDI.MidiEvent {
+			ticks?: number;
+			measure?: number;
+			ids?: string[];
+			staffTrack?: number;
+		};
+		type MidiTrack = MidiEvent[];
+
+		const eventPriority = (event: MidiEvent): number => event.ticks + (event.subtype === "noteOff" ? -1e-4 : 0);
+
+		const tracks: MidiTrack[] = [].concat(...measureEvents).reduce((tracks, mevent) => {
+			tracks[mevent.track] = tracks[mevent.track] || [];
+			tracks[mevent.track].push({
+				ticks: mevent.ticks,
+				...mevent.data,
+			});
+
+			return tracks;
+		}, []);
+
+		tracks[0] = tracks[0] || [];
+		tracks[0].push({
+			ticks: 0,
+			type: "meta",
+			subtype: "text",
+			text: `${npmPackage.name} ${npmPackage.version}`,
+		});
+
+		// append note events
+		measureTick = zeroTick;
+		measureIndices.map(index => {
+			const measure = this.measures[index - 1];
+			console.assert(!!measure, "invalid measure index:", index, this.measures.length);
+
+			measure.notes.forEach(note => {
+				if (trackList && !trackList[note.track])
+					return;
+
+				if (note.rest)
+					return;
+
+				const tick = measureTick + note.tick;
+
+				const track = tracks[note.track] = tracks[note.track] || [];
+
+				note.subNotes.forEach(subnote => {
+					track.push({
+						ticks: tick + subnote.startTick,
+						measure: index,
+						ids: note.ids,
+						type: "channel",
+						subtype: "noteOn",
+						channel: note.channel,
+						noteNumber: subnote.pitch,
+						velocity: subnote.velocity,
+						staffTrack: note.staffTrack,
+					});
+
+					track.push({
+						ticks: tick + subnote.endTick,
+						measure: index,
+						ids: note.ids,
+						type: "channel",
+						subtype: "noteOff",
+						channel: note.channel,
+						noteNumber: subnote.pitch,
+						velocity: 0,
+						staffTrack: note.staffTrack,
+					});
+				});
+			});
+
+			measureTick += measure.duration;
+		});
+
+		const finalTick = measureTick;
+
+		// ensure no empty track
+		for (let t = 0; t < tracks.length; ++t)
+			tracks[t] = tracks[t] || [];
+
+		// sort & make deltaTime
+		tracks.forEach(events => {
+			events.sort((e1, e2) => eventPriority(e1) - eventPriority(e2));
+
+			let ticks = 0;
+			events.forEach(event => {
+				event.deltaTime = event.ticks - ticks;
+				ticks = event.ticks;
+			});
+
+			events.push({deltaTime: Math.max(finalTick - ticks, 0), type: "meta", subtype: "endOfTrack"});
+		});
+
+		return {
+			header: {
+				formatType: 0,
+				ticksPerBeat: TICKS_PER_BEAT,
+			},
+			tracks,
+			zeroTick,
+		};
+	}
+
+
+	toPerformingNotationWithEvents (measureIndices: number[], options: {trackList?: boolean[]} = {}): MusicNotation.Notation {
+		if (!measureIndices.length)
+			return null;
+
+		const {zeroTick, ...midi} = this.toPerformingMIDI(measureIndices, options);
+		const notation = MusicNotation.Notation.parseMidi(midi);
+
+		assignNotationNoteDataFromEvents(notation);
+
+		let tick = zeroTick;
+
+		notation.measures = measureIndices.map(index => {
+			const startTick = tick;
+			tick += this.measures[index - 1].duration;
+
+			return {
+				index,
+				startTick,
+				endTick: tick,
+			};
+		});
+
+		return notation;
+	}
+
+
+	getContextGroup (measureIndices: number[]): PitchContextTable[] {
+		const contextGroup = this.pitchContextGroup.map(table => table.items.map(item => item.context));
+		const midiNotation = this.toPerformingNotation(measureIndices);
+
+		return PitchContextTable.createPitchContextGroup(contextGroup, midiNotation);
+	}
+
+
+	assignMatcher (matcher: MatcherResult): this {
+		const tickFactor = TICKS_PER_BEAT / matcher.sample.ticksPerBeat;
+
+		matcher.path.forEach((ci, si) => {
+			if (ci >= 0) {
+				const cn = matcher.criterion.notes[ci] as Note;
+				const sn = matcher.sample.notes[si] as Note;
+				sn.ids = cn.ids || [cn.id];
+				sn.measure = cn.measure;
+			}
+		});
+		assignNotationEventsIds(matcher.sample, ["ids", "measure"]);
+
+		// assign sub notes
+		const c2sIndices = Array(matcher.criterion.notes.length).fill(null).map(() => []);
+		matcher.path.forEach((ci, si) => ci >= 0 && c2sIndices[ci].push(si));
+
+		const velocities: {[key: number]: number} = {};
+		c2sIndices.forEach((indices, ci) => {
+			const cn = matcher.criterion.notes[ci] as any;
+			const measure = this.measures[cn.measure - 1];
+			console.assert(!!measure, "cannot find measure for c note:", cn, this.measures.length);
+
+			//const mn = measure.notes.find(note => note.tick === cn.startTick - measure.tick && note.pitch === cn.pitch);
+			const mn = measure.notes.find(note => note.id === cn.id && note.pitch === cn.pitch);
+			console.assert(!!mn, "cannot find measure note for c note:", cn, measure);
+
+			let bias = 0;
+
+			// arpeggio time bias
+			if (mn.implicitType === "arpeggio" && mn.chordPosition) {
+				const referenceDuration = Math.min(mn.duration * 0.5, ARPEGGIO_REFERENCE_DURATION);
+				bias = Math.round(mn.chordPosition.index * referenceDuration / mn.chordPosition.count);
+			}
+
+			const snotes = indices
+				.map(si => matcher.sample.notes[si])
+				.filter((sn, i) => Math.abs(sn.startTick - cn.startTick) < WHOLE_DURATION_MAGNITUDE
+					&& (!mn.afterGrace || i < 1)); // lilypond's afterGrace MIDI parsing is ill, clip notes to avoid error matching
+
+			if (!snotes.length) {
+				//const track = matcher.trackMap[mn.track];
+
+				mn.subNotes = [{
+					//track,
+					startTick: bias,
+					endTick: mn.duration,
+					pitch: mn.pitch,
+					velocity: velocities[mn.track] || 90,
+				}];
+			}
+			else {
+				const referenceTick = measure.tick + mn.tick;
+				//const referenceTick = snotes[0].startTick;
+				//console.log("mn bias:", mn.id, measure.tick + mn.tick - snotes[0].startTick);
+
+				mn.subNotes = snotes.map(sn => {
+					velocities[sn.track] = sn.velocity;
+
+					console.assert(sn.endTick > sn.startTick, "midi note duration is zero or negative:", sn);
+
+					// fix bad subnote duration
+					const duration = sn.endTick - sn.startTick;
+					if (duration > mn.duration * 2)
+						sn.endTick = sn.startTick + mn.duration;
+
+					return {
+						//track: sn.track,
+						startTick: Math.round(sn.startTick - referenceTick + bias),
+						endTick: Math.round(sn.endTick - referenceTick),
+						pitch: sn.pitch,
+						velocity: sn.velocity,
+					};
+				});
+			}
+		});
+
+		// assign events
+		this.measures.forEach(measure => measure.events = []);
+
+		//console.debug("matcher.trackMap:", matcher.trackMap);
+		(matcher.sample.events as MeasureEvent[]).forEach(event => {
+			// exclude note events
+			if (["noteOn", "noteOff"].includes(event.data.subtype))
+				return;
+
+			let track = matcher.trackMap[event.track];
+			if (!Number.isFinite(track)) {
+				const id = event.data.ids && event.data.ids[0];
+				track = id ? (this.idTrackMap[id] || 0) : 0;
+			}
+
+			if (Number.isInteger(event.data.measure)) {
+				const measure = this.measures[event.data.measure - 1];
+				console.assert(!!measure, "measure index is invalid:", event.data.measure, this.measures.length);
+
+				measure.events.push({
+					data: event.data,
+					track,
+					ticks: Math.round(event.ticks * tickFactor - measure.tick),
+				});
+			}
+			else {
+				switch (event.data.subtype) {
+				case "setTempo":
+				case "timeSignature":
+				case "keySignature": {
+					// find container measure by tick range
+					const tick = event.ticks * tickFactor;
+					const measure = this.measures.find(measure => tick >= measure.tick && tick < measure.tick + measure.duration);
+					if (measure) {
+						measure.events.push({
+							data: event.data,
+							track,
+							ticks: Math.round(tick - measure.tick),
+						});
+					}
+				}
+
+					break;
+				}
+			}
+		});
+
+		this.ripe = true;
+
+		return this;
+	}
+
+
+	// find the MIDI event of setTempo in measures data, and change the value of microsecondsPerBeat
+	setTempo (bpm: number): boolean {
+		let found = false;
+		for (const measure of this.measures) {
+			for (const event of measure.events) {
+				if (event.data.subtype === "setTempo") {
+					event.data.microsecondsPerBeat = 60e+6 / bpm;
+					found = true;
+				}
+			}
+		}
+
+		return found;
+	}
+};
+
+
+export const assignNotationEventsIds = (midiNotation: MusicNotation.NotationData, fields = ["ids"]) => {
+	const events = midiNotation.notes.reduce((events, note) => {
+		const dict = pick(note, fields);
+		events.push({ticks: note.startTick, subtype: "noteOn", channel: note.channel, pitch: note.pitch, dict});
+		events.push({ticks: note.endTick, subtype: "noteOff", channel: note.channel, pitch: note.pitch, dict});
+
+		["setTempo", "timeSignature", "keySignature"].forEach(subtype => events.push({ticks: note.startTick, subtype, dict}));
+
+		return events;
+	}, []).sort((e1, e2) => e1.ticks - e2.ticks);
+
+	let index = -1;
+	let ticks = -Infinity;
+	for (const event of midiNotation.events) {
+		console.assert(Number.isFinite(event.ticks), "invalid event ticks:", event);
+
+		while (event.ticks > ticks && index < events.length) {
+			++index;
+			ticks = events[index] && events[index].ticks;
+		}
+
+		if (index >= events.length)
+			break;
+
+		if (event.ticks < ticks)
+			continue;
+
+		for (let i = index; i < events.length; ++i) {
+			const ne = events[i];
+			if (!ne) {
+				console.warn("null event:", i, events.length);
+				break;
+			}
+
+			if (ne.ticks > ticks)
+				break;
+			else {
+				if (event.data.subtype === ne.subtype && event.data.channel === ne.channel && event.data.noteNumber === ne.pitch) {
+					Object.assign(event.data, ne.dict);
+					break;
+				}
+			}
+		}
+	}
+};
+
+
+const assignNotationNoteDataFromEvents = (midiNotation: MusicNotation.NotationData, fields = ["ids", "measure", "staffTrack"]) => {
+	const noteId = (channel: number, pitch: number, tick: number): string => `${channel}|${pitch}|${tick}`;
+
+	const noteMap = midiNotation.notes.reduce((map, note) => {
+		map[noteId(note.channel, note.pitch, note.startTick)] = note;
+
+		return map;
+	}, {});
+
+	midiNotation.events.forEach(event => {
+		if (event.data.subtype === "noteOn") {
+			const id = noteId(event.data.channel, event.data.noteNumber, event.ticks);
+			const note = noteMap[id];
+			console.assert(!!note, "cannot find note of", id);
+
+			if (note)
+				Object.assign(note, pick(event.data, fields));
+		}
+	});
+};

inc/lilyNotation/scheduler.ts

@@ -0,0 +1,167 @@
+
+import {MusicNotation} from "@k-l-lambda/music-widgets";
+
+import {ChordPosition} from "./notation";
+
+
+
+declare class StaffToken {
+	system?: number;
+	measure?: number;
+	x: number;
+	endX?: number;
+};
+
+
+interface TickItem {
+	tick: number;
+	endTick?: number;
+	system: number;
+	measure: number;
+	x: number;
+	endX: number;
+};
+
+
+interface SheetPosition {
+	system: number,
+	x: number,
+};
+
+
+interface Note extends MusicNotation.Note {
+	chordPosition?: ChordPosition;
+	measure?: number;
+	outMeasure?: boolean;
+};
+
+
+interface Notation {
+	notes: Note[];
+	endTick: number;
+};
+
+
+
+export default class Scheduler {
+	tickTable: TickItem[];
+
+
+	static createFromNotation (midiNotation: Notation, tokenMap: Map<string, StaffToken>): Scheduler {
+		const tokenTable: {[key: number]: StaffToken[]} = {};
+		const idSet = new Set<string>();
+		let measureIndex = 0;
+
+		midiNotation.notes.filter(note => !note.outMeasure && (!note.chordPosition || note.chordPosition.index === 0)).forEach(note => {
+			if (note.ids) {
+				if (note.measure !== measureIndex) {
+					idSet.clear();
+					measureIndex = note.measure;
+				}
+				else if (note.ids.some(id => idSet.has(id)))
+					return;
+				note.ids.forEach(idSet.add.bind(idSet));
+
+				tokenTable[note.startTick] = tokenTable[note.startTick] || [];
+				const tokens = note.ids.map(id => tokenMap.get(id)).filter(t => t);
+				tokenTable[note.startTick].push(...tokens);
+			}
+		});
+		//console.log("tokenTable:", tokenTable);
+
+		return Scheduler.createFromTokenTable(tokenTable, midiNotation.endTick);
+	}
+
+
+	static createFromTokenTable (tokenTable: {[key: number]: StaffToken[]}, endTick: number): Scheduler {
+		const tickTable: TickItem[] = Object.entries(tokenTable).map(([tick, tokens]) => {
+			if (!tokens.length)
+				return null;
+	
+			tokens.sort((t1, t2) => t1.system === t2.system ? t1.x - t2.x : t1.system - t2.system);
+			const token = tokens[0];
+	
+			return {
+				tick: Number(tick),
+				system: token.system,
+				measure: token.measure,
+				x: token.x,
+				endX: token.endX,
+			};
+		}).filter(Boolean).sort((i1, i2) => i1.tick - i2.tick);
+		//console.log("sequence:", sequence);
+
+		tickTable.forEach((item, i) => {
+			const nextItem = tickTable[i + 1];
+
+			item.endTick = nextItem ? nextItem.tick : endTick;
+			console.assert(item.endTick > item.tick, "invalid tick item, tick span is non-positive:", item, tokenTable[item.tick]);
+
+			if (nextItem && item.system === nextItem.system && [0, 1].includes(nextItem.measure - item.measure))
+				item.endX = nextItem.x;
+		});
+
+		return new Scheduler({
+			tickTable,
+		});
+	}
+
+
+	constructor ({tickTable}: {tickTable: TickItem[]}) {
+		console.assert(tickTable.length > 0, "invalid tick table:", tickTable);
+
+		this.tickTable = tickTable;
+	}
+
+
+	get startTick (): number {
+		if (!this.tickTable[0])
+			return null;
+
+		return this.tickTable[0].tick;
+	}
+
+
+	get endTick (): number {
+		if (!this.tickTable[0])
+			return null;
+
+		return this.tickTable[this.tickTable.length - 1].endTick;
+	}
+
+
+	lookupPosition (tick: number): SheetPosition {
+		tick = Math.max(Math.min(tick, this.endTick), this.startTick);
+
+		const item = this.tickTable.find(item => item.tick <= tick && item.endTick > tick) || this.tickTable[this.tickTable.length - 1];
+		if (!item) {
+			console.warn("cannot find tick item:", tick, this.tickTable);
+			return null;
+		}
+
+		const x = item.x + (tick - item.tick) * (item.endX - item.x) / (item.endTick - item.tick);
+
+		return {
+			system: item.system,
+			x,
+		};
+	}
+
+
+	lookupTick (position: SheetPosition): number {
+		const rowItems = this.tickTable.filter(item => item.system === position.system).sort((i1, i2) => i1.x - i2.x);
+		let item = rowItems.find(item => item.x <= position.x && item.endX >= position.x);
+		if (!item) {
+			const firstItem = rowItems[0];
+			if (firstItem && position.x < firstItem.endX)
+				item = firstItem;
+			else
+				//console.warn("lookup position out of range:", position, this.tickTable);
+				return null;
+		}
+
+		const tick = item.tick + Math.max(position.x - item.x, 0) * (item.endTick - item.tick) / (item.endX - item.x);
+
+		return tick;
+	}
+};

inc/lilyParser/idioms.ts

@@ -0,0 +1,51 @@
+
+const PHONETS = "cdefgab";
+const PHONETS_ALIAS = {
+	h: "b",
+};
+
+const phonetDifferToShift = differ => differ > 3 ? -1 : (differ < -3 ? 1 : 0);
+
+const PHONET_VALUES = {
+	c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11,
+};
+
+
+const SHARP_ALTERS = [
+	"is", "d", "s", "iss", "k", "sharp",
+];
+const FLAT_ALTERS = [
+	"es", "b", "f", "ess", "flat",
+];
+// in Dutch, 'as', 'es' means a flat/e flat, that's not supported here
+
+const DOUBLE_SHARP_ALTERS = [
+	...SHARP_ALTERS.map(word => word + word), "x",
+];
+const DOUBLE_FLAT_ALTERS = [
+	...FLAT_ALTERS.map(word => word + word), "ses",
+];
+
+const alterTablize = (list, value) => list.reduce((table, word) => ((table[word] = value), table), {});
+
+
+const ALTER_VALUES = {
+	...alterTablize(SHARP_ALTERS, 1),
+	...alterTablize(FLAT_ALTERS, -1),
+	...alterTablize(DOUBLE_SHARP_ALTERS, 2),
+	...alterTablize(DOUBLE_FLAT_ALTERS, -2),
+};
+
+
+const FIFTH_PHONETS = "fcgdaeb";
+
+
+
+export {
+	PHONETS,
+	PHONETS_ALIAS,
+	phonetDifferToShift,
+	PHONET_VALUES,
+	ALTER_VALUES,
+	FIFTH_PHONETS,
+};

inc/lilyParser/index.ts

@@ -0,0 +1,28 @@
+
+import {termDictionary, getDurationSubdivider, BaseTerm, MusicEvent} from "./lilyTerms";
+import LilyDocument from "./lilyDocument";
+import LilyInterpreter, {MusicTrack, TrackContext, TremoloType} from "./lilyInterpreter";
+export * from "./utils";
+
+import * as measures from "./measures";
+import {createPianoRhythm} from "./pianoRhythm";
+
+
+
+const LilyTerms = termDictionary;
+
+
+
+export {
+	LilyDocument,
+	LilyInterpreter,
+	MusicTrack,
+	TrackContext,
+	TremoloType,
+	BaseTerm,
+	MusicEvent,
+	LilyTerms,
+	getDurationSubdivider,
+	measures,
+	createPianoRhythm,
+};

inc/lilyParser/lilyDocument.ts

@@ -0,0 +1,1062 @@
+
+import TextSource from "../textSource";
+import {LILY_STAFF_SIZE_DEFAULT} from "../constants";
+import {
+	parseRaw,
+	BaseTerm, Assignment, LiteralString, Command, Variable, MarkupCommand, Grace, AfterGrace, Include, Version, Block, InlineBlock,
+	Scheme, Chord, BriefChord, Lyric, MusicBlock, SimultaneousList, ContextedMusic, Divide, Tempo, PostEvent, Primitive, ChordElement, MusicEvent,
+	SchemePointer, Comment, Language, StemDirection,
+} from "./lilyTerms";
+import LilyInterpreter from "./lilyInterpreter";
+import {MAIN_SCORE_NAME, DocLocation} from "./utils";
+
+// eslint-disable-next-line
+import {Root} from "./lilyTerms";
+
+
+
+type AttributeValue = number | boolean | string | BaseTerm;
+
+interface AttributeValueHandle {
+	value: AttributeValue;
+};
+
+
+export interface LilyDocumentAttribute {
+	[key: string]: AttributeValueHandle
+};
+
+export interface LilyDocumentAttributeReadOnly {
+	staffSize: number;
+	[key: string]: AttributeValue
+};
+
+
+
+export default class LilyDocument {
+	root: Root;
+
+	cacheInterpreter?: LilyInterpreter;
+
+	reservedVariables?: Set<string>;
+
+
+	constructor (data: object) {
+		//console.log("raw data:", data);
+		this.root = parseRaw(data);
+	}
+
+
+	toString () {
+		return this.root.join();
+		//return this.root.serialize();
+	}
+
+
+	interpret ({useCached = true} = {}): LilyInterpreter {
+		if (!useCached || !this.cacheInterpreter) {
+			this.cacheInterpreter = new LilyInterpreter();
+			this.cacheInterpreter.interpretDocument(this);
+		}
+
+		return this.cacheInterpreter;
+	}
+
+
+	globalAttributes ({readonly = false} = {}): LilyDocumentAttribute | LilyDocumentAttributeReadOnly {
+		const globalStaffSize = this.root.getField("set-global-staff-size");
+		const header = this.root.getBlock("header");
+		let paper = this.root.getBlock("paper");
+		const layoutStaffSize = paper && paper.getField("layout-set-staff-size");
+		let staffSize = globalStaffSize || layoutStaffSize;
+
+		if (!readonly) {
+			let sectionsDirty = false;
+
+			if (!staffSize) {
+				this.root.sections.push(new Scheme({exp: {proto: "SchemeFunction", func: "set-global-staff-size", args: [LILY_STAFF_SIZE_DEFAULT]}}));
+				staffSize = this.root.getField("set-global-staff-size");
+
+				sectionsDirty = true;
+			}
+
+			// A4 paper size
+			const DEFAULT_PAPER_WIDTH = {
+				proto: "Assignment",
+				key: "paper-width",
+				value: {proto: "NumberUnit", number: 21, unit: "\\cm"},
+			};
+			const DEFAULT_PAPER_HEIGHT = {
+				proto: "Assignment",
+				key: "paper-height",
+				value: {proto: "NumberUnit", number: 29.71, unit: "\\cm"},
+			};
+
+			if (!paper) {
+				paper = new Block({
+					block: "score",
+					head: "\\paper",
+					body: [DEFAULT_PAPER_WIDTH, DEFAULT_PAPER_HEIGHT],
+				});
+				this.root.sections.push(paper);
+
+				sectionsDirty = true;
+			}
+
+			if (!paper.getField("paper-width")) 
+				paper.body.push(parseRaw(DEFAULT_PAPER_WIDTH));
+
+			if (!paper.getField("paper-height")) 
+				paper.body.push(parseRaw(DEFAULT_PAPER_HEIGHT));
+
+			if (sectionsDirty)
+				this.root.reorderSections();
+		}
+		else
+			staffSize = staffSize || {value: LILY_STAFF_SIZE_DEFAULT};
+
+		const blockPropertyCommon = (block: Block, key: string) => ({
+			get value () {
+				if (!block)
+					return undefined;
+
+				const item = block.getField(key);
+				if (!item)
+					return undefined;
+
+				return item.value;
+			},
+
+			set value (value) {
+				console.assert(!!block, "block is null.");
+
+				if (value === undefined)	// delete field
+					block.body = block.body.filter(assign => !(assign instanceof Assignment) || assign.key !== key);
+				else {
+					const item = block.getField(key);
+					if (item)
+						item.value = parseRaw(value);
+					else
+						block.body.push(new Assignment({key, value}));
+				}
+			},
+		});
+		const paperPropertyCommon = key => blockPropertyCommon(paper, key);
+
+		const paperPropertySchemeToken = key => ({
+			get value () {
+				if (!paper)
+					return undefined;
+
+				const item = paper.getField(key);
+				if (!item)
+					return undefined;
+
+				return item.value.exp;
+			},
+
+			set value (value) {
+				console.assert(!!paper, "paper is null.");
+
+				const item = paper.getField(key);
+				if (item)
+					item.value.exp = value;
+				else
+					paper.body.push(new Assignment({key, value: {proto: "Scheme", exp: value}}));
+			},
+		});
+
+		let midiBlock = null;
+		const scores = this.root.sections.filter(section => section instanceof Block && section.head === "\\score") as Block[];
+		for (const score of scores) {
+			midiBlock = score.body.find(term => term instanceof Block && term.head === "\\midi");
+			if (midiBlock)
+				break;
+		}
+
+		const midiTempo = {
+			get value (): Tempo {
+				return midiBlock && midiBlock.body.find(term => term instanceof Tempo);
+			},
+
+			set value (value: Tempo) {
+				if (!midiBlock) {
+					const score = this.root.getBlock("score");
+					if (score) {
+						midiBlock = new Block({block: "score", head: "\\midi", body: []});
+						score.body.push(midiBlock);
+					}
+					else
+						console.warn("no score block, midiTempo assign failed.");
+				}
+
+				if (midiBlock) {
+					midiBlock.body = midiBlock.body.filter(term => !(term instanceof Tempo));
+					midiBlock.body.push(value);
+				}
+			},
+		};
+
+		const assignments = this.root.entries.filter(term => term instanceof Assignment) as Assignment[];
+		const assignmentTable = assignments.reduce((table, assign) => ((table[assign.key.toString()] = assign.query(assign.key)), table), {});
+
+		const headerFields = [
+			"title", "subtitle", "subsubtitle", "composer", "poet", "arranger", "opus", "copyright", "instrument", "dedication", "tagline",
+		].reduce((dict, field) => ((dict[field] = blockPropertyCommon(header, field)), dict), {});
+
+		const attributes = {
+			staffSize,
+			midiTempo,
+			...headerFields,
+			paperWidth: paperPropertyCommon("paper-width"),
+			paperHeight: paperPropertyCommon("paper-height"),
+			topMargin: paperPropertyCommon("top-margin"),
+			bottomMargin: paperPropertyCommon("bottom-margin"),
+			leftMargin: paperPropertyCommon("left-margin"),
+			rightMargin: paperPropertyCommon("right-margin"),
+			systemSpacing: paperPropertySchemeToken("system-system-spacing.basic-distance"),
+			topMarkupSpacing: paperPropertySchemeToken("top-markup-spacing.basic-distance"),
+			raggedLast: paperPropertySchemeToken("ragged-last"),
+			raggedBottom: paperPropertySchemeToken("ragged-bottom"),
+			raggedLastBottom: paperPropertySchemeToken("ragged-last-bottom"),
+			printPageNumber: paperPropertySchemeToken("print-page-number"),
+			...assignmentTable,
+		};
+
+		if (readonly)
+			Object.keys(attributes).forEach(key => attributes[key] = attributes[key] && attributes[key].value);
+
+		return attributes;
+	}
+
+
+	globalAttributesReadOnly (): LilyDocumentAttributeReadOnly {
+		const attributes = this.globalAttributes() as any;
+		Object.keys(attributes).forEach(key => attributes[key] = attributes[key] && attributes[key].value);
+
+		return attributes;
+	}
+
+
+	markup (docMarkup: LilyDocument) {
+		// copy attributes
+		const attrS = this.globalAttributes() as LilyDocumentAttribute;
+		const attrM = docMarkup.globalAttributesReadOnly();
+
+		[
+			"staffSize", "midiTempo", "paperWidth", "paperHeight",
+			"topMargin", "bottomMargin", "leftMargin", "rightMargin",
+			"systemSpacing", "topMarkupSpacing", "raggedLast", "raggedBottom", "raggedLastBottom",
+			"printPageNumber",
+		].forEach(field => {
+			if (attrM[field] !== undefined) {
+				if (typeof attrS[field].value === "object" && attrS[field].value && (attrS[field].value as any).set)
+					(attrS[field].value as any).set(attrM[field]);
+				else
+					attrS[field].value = attrM[field];
+			}
+		});
+
+		// execute commands list
+		const commands = docMarkup.root.getField("LotusCommands");
+		const cmdList = commands && commands.value && commands.value.args && commands.value.args[0].body;
+		if (cmdList && Array.isArray(cmdList)) {
+			for (const command of cmdList) {
+				if (command.exp && this[command.exp])
+					this[command.exp]();
+				else
+					console.warn("unexpected markup command:", command);
+			}
+		}
+
+		// copy LotusOption assignments
+		const assignments = docMarkup.root.entries.filter(term => term instanceof Assignment && /^LotusOption\..+/.test(term.key.toString()));
+		assignments.forEach(assignment => this.root.sections.push(assignment.clone()));
+
+		// copy score blocks
+		const layoutBody = [];
+		const midiBody = [];
+		const score = docMarkup.root.getBlock("score");
+		if (score) {
+			const layout = score.body.find(term => term instanceof Block && term.head === "\\layout") as Block;
+			if (layout)
+				layout.body.forEach(term => layoutBody.push(term.clone()));
+
+			const midi = score.body.find(term => term instanceof Block && term.head === "\\midi") as Block;
+			if (midi)
+				midi.body.forEach(term => midiBody.push(term.clone()));
+		}
+		if (layoutBody.length || midiBody.length) {
+			const thisScore = this.root.getBlock("score");
+			if (thisScore) {
+				const layout = thisScore.body.find(term => term instanceof Block && term.head === "\\layout") as Block;
+				if (layout)
+					layout.body.push(...layoutBody);
+
+				const midi = thisScore.body.find(term => term instanceof Block && term.head === "\\midi") as Block;
+				if (midi)
+					midi.body.push(...midiBody);
+			}
+		}
+	}
+
+
+	getVariables (): Set<string> {
+		return new Set(this.root.findAll(Variable).map(variable => variable.name));
+	}
+
+
+	// deprecated
+	getMusicTracks ({expand = false} = {}): MusicBlock[] {
+		const score = this.root.getBlock("score");
+		if (!score)
+			return null;
+
+		let tracks = [];
+
+		// extract sequential music blocks from score block
+		score.forEachTopTerm(MusicBlock, block => {
+			tracks.push(block);
+		});
+
+		// expand variables in tracks
+		if (expand)
+			tracks = tracks.map(track => track.clone().expandVariables(this.root));
+
+		return tracks;
+	}
+
+
+	getLocationTickTable (): {[key: string]: number} {
+		const notes = this.root.findAll(term => (term instanceof ChordElement) || (term instanceof MusicEvent));
+
+		return notes.reduce((table, note) => {
+			if (note._location && Number.isFinite(note._tick))
+				table[`${note._location.lines[0]}:${note._location.columns[0]}`] = note._tick;
+
+			return table;
+		}, {});
+	}
+
+
+	// update terms' _location data according to a serialized source
+	relocate (source: string = this.toString()) {
+		this.root.relocate(source);
+	}
+
+
+	appendIncludeFile (filename: string) {
+		if (!this.root.includeFiles.includes(filename)) {
+			const versionPos = this.root.sections.findIndex(term => term instanceof Version);
+			this.root.sections.splice(versionPos + 1, 0,
+				new Include({cmd: "include", args: [LiteralString.fromString(filename)]}));
+		}
+	}
+
+
+	removeStaffGroup () {
+		const score = this.root.getBlock("score");
+		if (score) {
+			score.body.forEach(item => {
+				if (item instanceof SimultaneousList)
+					item.removeStaffGroup();
+			});
+		}
+	}
+
+
+	fixTinyTrillSpans () {
+		// TODO: replace successive \startTrillSpan & \stopTrillSpan with ^\trill
+	}
+
+
+	removeMusicCommands (cmds: string | string[]) {
+		cmds = Array.isArray(cmds) ? cmds : [cmds];
+
+		const isToRemoved = item => (item instanceof Command) && cmds.includes(item.cmd);
+
+		this.root.forEachTerm(MusicBlock, block => {
+			block.body = block.body.filter(item => !isToRemoved(item));
+		});
+	}
+
+
+	removeTrillSpans () {
+		this.removeMusicCommands(["startTrillSpan", "stopTrillSpan"]);
+	}
+
+
+	removeBreaks () {
+		this.removeMusicCommands("break");
+	}
+
+
+	removePageBreaks () {
+		this.removeMusicCommands("pageBreak");
+	}
+
+
+	scoreBreakBefore (enabled = true) {
+		const score = this.root.getBlock("score");
+		if (score) {
+			let header = score.entries.find((entry: any) => entry.head === "\\header") as Block;
+			if (!header) {
+				header = new Block({head: "\\header", body: []});
+				score.body.push(header);
+			}
+
+			let breakbefore = header.getField("breakbefore");
+			if (breakbefore) 
+				breakbefore = breakbefore.value;
+			
+			else {
+				breakbefore = new Scheme({exp: true});
+				header.body.push(new Assignment({key: "breakbefore", value: breakbefore}));
+			}
+
+			breakbefore.exp = enabled;
+		}
+		else
+			console.warn("no score block");
+	}
+
+
+	unfoldRepeats () {
+		const score = this.root.getBlock("score");
+		const musicList = score ? score.body : this.root.sections;
+
+		let count = 0;
+
+		musicList.forEach((term, i) => {
+			if (term.isMusic && (term as Command).cmd !== "unfoldRepeats") {
+				const unfold = new Command({cmd: "unfoldRepeats", args: [term]});
+				musicList.splice(i, 1, unfold);
+
+				++count;
+			}
+		});
+
+		if (!count)
+			console.warn("no music term to unfold");
+
+		return count;
+	}
+
+
+	containsRepeat (): boolean {
+		const termContainsRepeat = (term: BaseTerm): boolean => {
+			if (!term.entries)
+				return false;
+
+			const subTerms = term.entries.filter(term => term instanceof BaseTerm);
+
+			for (const term of subTerms) {
+				if ((term as Command).cmd === "repeat")
+					return true;
+			}
+
+			for (const term of subTerms) {
+				if (termContainsRepeat(term))
+					return true;
+			}
+
+			return false;
+		};
+
+		return termContainsRepeat(this.root);
+	}
+
+
+	removeEmptySubMusicBlocks () {
+		this.root.forEachTerm(MusicBlock, block => {
+			block.body = block.body.filter(term => !(term instanceof MusicBlock && term.body.length === 0));
+		});
+	}
+
+
+	mergeContinuousGraces () {
+		this.removeEmptySubMusicBlocks();
+
+		const isGraceCommand = term => term instanceof Grace;
+		const isGraceInnerTerm = term => isGraceCommand(term) || term instanceof Divide || term instanceof PostEvent;
+
+		this.root.forEachTerm(MusicBlock, block => {
+			const groups = [];
+			let currentGroup = null;
+
+			block.body.forEach((term, i) => {
+				if (currentGroup) {
+					if (isGraceInnerTerm(term)) {
+						currentGroup.count++;
+
+						if (currentGroup.count === 2)
+							groups.push(currentGroup);
+					}
+					else
+						currentGroup = null;
+				}
+				else {
+					if (isGraceCommand(term))
+						currentGroup = {start: i, count: 1};
+				}
+			});
+
+			let offset = 0;
+			groups.forEach(group => {
+				const startIndex = group.start + offset;
+				const mainBody = new MusicBlock({body: []});
+
+				for (let i = startIndex; i < startIndex + group.count; ++ i) {
+					const term = block.body[i];
+					const music = isGraceCommand(term) ? term.args[0] : term;
+					if (music instanceof MusicBlock)
+						mainBody.body.push(...music.body);
+					else
+						mainBody.body.push(music);
+				}
+
+				block.body[startIndex].args[0] = mainBody;
+				block.body.splice(startIndex + 1, group.count - 1);
+
+				offset -= group.count - 1;
+			});
+		});
+	}
+
+
+	mergeContinuousEmptyAfterGraces () {
+		const isEmptyAfterGrace = term => term instanceof AfterGrace && term.args[0] instanceof MusicBlock && term.args[0].body.length === 0;
+		const isGraceInnerTerm = term => isEmptyAfterGrace(term) || term instanceof Divide || term instanceof PostEvent;
+
+		this.root.forEachTerm(MusicBlock, block => {
+			const groups = [];
+			let currentGroup = null;
+
+			block.body.forEach((term, i) => {
+				if (currentGroup) {
+					if (isGraceInnerTerm(term)) {
+						currentGroup.count++;
+
+						if (currentGroup.count === 2)
+							groups.push(currentGroup);
+					}
+					else
+						currentGroup = null;
+				}
+				else {
+					if (isEmptyAfterGrace(term))
+						currentGroup = {start: i, count: 1};
+				}
+			});
+
+			let offset = 0;
+			groups.forEach(group => {
+				const startIndex = group.start + offset;
+				const mainBody = new MusicBlock({body: []});
+
+				for (let i = startIndex; i < startIndex + group.count; ++ i) {
+					const term = block.body[i];
+					const music = isEmptyAfterGrace(term) ? term.args[1] : term;
+					if (music instanceof MusicBlock)
+						mainBody.body.push(...music.body);
+					else
+						mainBody.body.push(music);
+				}
+
+				block.body[startIndex].args[1] = mainBody;
+				block.body.splice(startIndex + 1, group.count - 1);
+
+				offset -= group.count - 1;
+			});
+		});
+	}
+
+
+	fixInvalidKeys (mode = "major") {
+		this.root.forEachTerm(Command, cmd => {
+			if (cmd.cmd === "key") {
+				if (cmd.args[1] === "\\none")
+					cmd.args[1] = "\\" + mode;
+			}
+		});
+	}
+
+
+	fixInvalidBriefChords () {
+		this.root.forEachTerm(BriefChord, chord => {
+			const items = chord.body.items;
+			if (items) {
+				// merge multiple ^ items
+				while (items.filter(item => item === "^").length > 1) {
+					const index = items.lastIndexOf("^");
+					items.splice(index, 1, ".");
+				}
+			}
+		});
+	}
+
+
+	fixInvalidMarkupWords () {
+		this.root.forEachTerm(MarkupCommand, cmd => {
+			//console.log("markup:", cmd);
+			cmd.forEachTerm(InlineBlock, block => {
+				// replace scheme expression by literal string
+				block.body = block.body.map(term => {
+					if (term instanceof Scheme)
+						return LiteralString.fromString(term.join().replace(/\s+$/, ""));
+
+					if (typeof term === "string" && term.includes("$"))
+						return LiteralString.fromString(term);
+
+					return term;
+				});
+			});
+		});
+	}
+
+
+	fixNestedRepeat () {
+		// \repeat { \repeat { P1 } \alternative { {P2} } } \alternative { {P3} }
+		// ->
+		// \repeat { P1 } \alternative { {P2} {P3} }
+		this.root.forEachTerm(Command, cmd => {
+			if (cmd.isRepeatWithAlternative) {
+				const block = cmd.args[2];
+				const alternative = cmd.args[3].args[0];
+				const lastMusic = block.body[block.body.length - 1];
+				if (lastMusic && lastMusic.isRepeatWithAlternative) {
+					block.body.splice(block.body.length - 1, 1, ...lastMusic.args[2].body);
+					alternative.body = [...lastMusic.args[3].args[0].body, ...alternative.body];
+				}
+			}
+		});
+	}
+
+
+	fixEmptyContextedStaff () {
+		// staff.1 << >>				staff.2 << voice.1 {} voice.2 {} >>
+		// ->
+		// staff.1 << voice.1 {} >>		staff.2 << voice.2 {} >>
+		const subMusics = (simul: SimultaneousList) => simul.list.filter(term => term instanceof ContextedMusic);
+
+		const score = this.root.getBlock("score");
+		score.forEachTerm(SimultaneousList, simul => {
+			const staves = simul.list.filter(term => term instanceof ContextedMusic && term.body instanceof SimultaneousList);
+			if (staves.length > 1) {
+				const staff1 = staves[0].body;
+				const staff2 = staves[1].body;
+
+				if (subMusics(staff1).length === 0 && subMusics(staff2).length > 1) {
+					const index = staff2.list.findIndex(term => term instanceof ContextedMusic);
+					const [music] = staff2.list.splice(index, 1);
+					staff1.list.push(music);
+				}
+			}
+		});
+	}
+
+
+	removeEmptyContextedStaff () {
+		const subMusics = (simul: SimultaneousList) => simul.list.filter(term => term instanceof ContextedMusic);
+
+		const score = this.root.getBlock("score");
+		score.forEachTerm(SimultaneousList, simul => {
+			simul.list = simul.list.filter(term => !(term instanceof ContextedMusic) || !(term.body instanceof SimultaneousList)
+				|| subMusics(term.body).length > 0);
+		});
+	}
+
+
+	redivide () {
+		this.root.forEachTopTerm(MusicBlock, (block: MusicBlock) => block.redivide());
+	}
+
+
+	makeMIDIDedicatedScore (): Block {
+		const block = this.root.findFirst(term => term instanceof Block && term.head === "\\score" && term.isMIDIDedicated) as Block;
+		if (block)
+			return block;
+
+		const score = this.root.getBlock("score");
+		const newScore = score.clone();
+
+		newScore.body = newScore.body.filter(term => !(term instanceof Block && term.head === "\\layout"));
+		score.body = score.body.filter(term => !(term instanceof Block && term.head === "\\midi"));
+
+		this.root.sections.push(newScore);
+
+		return newScore;
+	}
+
+
+	excludeChordTracksFromMIDI () {
+		// if there is chord mode music in score, duplicate score block as a dedicated MIDI score which excludes chord mode music.
+		let contains = false;
+
+		const isChordMusic = term => term instanceof ContextedMusic
+			&& term.head instanceof Command && term.head.args[0] === "ChordNames";
+
+		const isBlock = (head, term) => term instanceof Block && term.head === head;
+
+		// TODO: midiMusic forked in interpreter issue
+		//this.abstractMainScore();
+
+		const score = this.root.getBlock("score");
+		const newScore = score.clone() as Block;
+		newScore.forEachTerm(SimultaneousList, simul => {
+			const trimmedList = simul.list.filter(term => !isChordMusic(term));
+			if (trimmedList.length < simul.list.length) {
+				simul.list = trimmedList;
+				contains = true;
+			}
+		});
+		newScore._headComment = Comment.createSingle(" midi output");
+
+		if (contains) {
+			const trimmedBody = score.body.filter(term => !isBlock("\\midi", term));
+			if (trimmedBody.length < score.body.length) {
+				score.body = trimmedBody;
+
+				newScore.body = newScore.body.filter(term => !isBlock("\\layout", term));
+				this.root.sections.push(newScore);
+			}
+		}
+	}
+
+
+	// [deprecated]
+	// generate tied notehead location candidates
+	getTiedNoteLocations (source: TextSource): DocLocation[] {
+		const chordPairs: [Chord, Chord][] = [];
+
+		const hasMusicBlock = term => {
+			if (term instanceof MusicBlock)
+				return true;
+
+			if (term instanceof Command)
+				return term.args.filter(arg => arg instanceof MusicBlock).length > 0;
+
+			return false;
+		};
+
+		this.root.forEachTerm(MusicBlock, (block: MusicBlock) => {
+			for (const voice of block.voices) {
+				let lastChord: Chord = null;
+				let tying = false;
+				let afterBlock = false;
+				let atHead = true;
+
+				for (const chunk of voice.body) {
+					for (const term of chunk.terms) {
+						if (term instanceof Primitive && term.exp === "~") {
+							tying = true;
+							afterBlock = false;
+						}
+						else if (hasMusicBlock(term)) {
+							afterBlock = true;
+							tying = false;
+							//console.log("afterBlock:", term);
+						}
+						else if (term instanceof Chord) {
+							if (tying && lastChord) 
+								chordPairs.push([lastChord, term]);
+							// maybe there is a tie at tail of the last block
+							else if (afterBlock)
+								chordPairs.push([null, term]);
+							// maybe there is a tie before the current block
+							else if (atHead)
+								chordPairs.push([null, term]);
+
+							// PENDING: maybe some user-defined command block contains tie at tail.
+
+							atHead = false;
+							afterBlock = false;
+							tying = false;
+							lastChord = term;
+
+							if (term.post_events) {
+								for (const event of term.post_events) {
+									if (event instanceof PostEvent && event.arg === "~")
+										tying = true;
+								}
+							}
+						}
+					}
+				}
+			}
+		});
+
+		//console.log("chordPairs:", chordPairs);
+
+		const locations = [];
+
+		chordPairs.forEach(pair => {
+			const forePitches = pair[0] && new Set(pair[0].pitchNames);
+
+			const chordSource = source.slice(pair[1]._location.lines, pair[1]._location.columns);
+			const pitchColumns = TextSource.matchPositions(/\w+/g, chordSource);
+
+			pair[1].pitchNames
+				.map((pitch, index) => ({pitch, index}))
+				.filter(({pitch}) => !forePitches || forePitches.has(pitch) || pitch === "q")
+				.forEach(({index}) => locations.push([
+					pair[1]._location.lines[0],	// line
+					pair[1]._location.columns[0] + pitchColumns[index],	// column
+				]));
+		});
+
+		return locations;
+	}
+
+
+	// generate tied notehead location candidates
+	getTiedNoteLocations2 (): DocLocation[] {
+		const locations = [];
+
+		this.root.forEachTerm(Chord, chord => chord.pitches.forEach(pitch => {
+			if (pitch._tied)
+				locations.push([pitch._location.lines[0], pitch._location.columns[0]]);
+		}));
+
+		return locations;
+	}
+
+
+	getBriefChordLocations (): DocLocation[] {
+		const locations = [];
+
+		this.root.forEachTerm(BriefChord,
+			chord => locations.push([chord._location.lines[0], chord._location.columns[0]]));
+
+		return locations;
+	}
+
+
+	getLyricLocations (): DocLocation[] {
+		const locations = [];
+
+		this.root.forEachTerm(Lyric,
+			lyric => locations.push([lyric._location.lines[0], lyric._location.columns[0]]));
+
+		return locations;
+	}
+
+
+	/*removeAloneSpacer () {
+		this.root.forEachTopTerm(MusicBlock, block => {
+			const aloneSpacers = cc(block.musicChunks.filter(chunk => chunk.size === 1 && chunk.terms[0].isSpacer).map(chunk => chunk.terms));
+			//console.log("aloneSpacers:", aloneSpacers.map(s => s._location));
+
+			if (aloneSpacers.length) {
+				const removeInBlock = block => block.body = block.body.filter(term => !aloneSpacers.includes(term));
+
+				removeInBlock(block);
+				block.forEachTerm(MusicBlock, removeInBlock);
+			}
+		});
+	}*/
+
+
+	unfoldDurationMultipliers () {
+		this.root.forEachTerm(MusicBlock, block => {
+			block.unfoldDurationMultipliers();
+		});
+	}
+
+
+	appendMIDIInstrumentsFromName () {
+		const isSet = (term: BaseTerm, keyPattern: RegExp): boolean => term instanceof Command && term.cmd === "set" && keyPattern.test((term.args[0] as Assignment).key.toString());
+		const append = (body: BaseTerm[]) => {
+			const ntIndex = body.findIndex(term => isSet(term, /\.instrumentName/));
+			if (ntIndex >= 0 && !body.some(term => isSet(term, /\.midiInstrument/))) {
+				const nameAssign = (body[ntIndex] as Command).args[0] as Assignment;
+				const key = nameAssign.key.toString().replace(/\.instrumentName/, ".midiInstrument");
+				body.splice(ntIndex + 1, 0, Command.createSet(key, nameAssign.value));
+			}
+		};
+
+		this.root.forEachTopTerm(Block, block => {
+			if (block.head === "\\score") {
+				block.forEachTerm(SimultaneousList, simu => append(simu.list));
+				block.forEachTerm(MusicBlock, musicBlock => append(musicBlock.body));
+			}
+		});
+	}
+
+
+	useMidiInstrumentChannelMapping () {
+		this.appendMIDIInstrumentsFromName();
+
+		const midiBlock = this.root.findFirst(term => term instanceof Block && term.head === "\\midi") as Block;
+		if (!midiBlock) {
+			console.warn("no MIDI block found.");
+			return;
+		}
+
+		const channelMapping = midiBlock.findFirst(term => term instanceof Assignment && term.key === "midiChannelMapping") as Assignment;
+		if (channelMapping)
+			channelMapping.value = new Scheme({exp: new SchemePointer({value: "instrument"})});
+		else {
+			midiBlock.body.push(parseRaw({
+				proto: "Block",
+				block: "context",
+				head: "\\context",
+				body: [
+					{proto: "Command",cmd: "Score",args: []},
+					{proto: "Assignment", key: "midiChannelMapping", value: {proto: "Scheme", exp: {proto: "SchemePointer", value: "instrument"}}},
+				],
+			}));
+		}
+	}
+
+
+	formalize () {
+		if (!this.root.findFirst(Version))
+			this.root.sections.unshift(Version.default);
+
+		if (!this.root.findFirst(Language))
+			this.root.sections.splice(1, 0, Language.make("english"));
+
+		if (!this.root.getBlock("header"))
+			this.root.sections.splice(2, 0, new Block({block: "header", head: "\\header", body:[]}));
+
+		if (!this.root.getBlock("score")) {
+			const topMusics = this.root.sections.filter(section => section.isMusic);
+			this.root.sections = this.root.sections.filter(section => !section.isMusic);
+
+			const score = new Block({block: "score", head: "\\score", body: [
+				...topMusics,
+				new Block({block: "score", head: "\\layout", body: []}),
+				new Block({block: "score", head: "\\midi", body: []}),
+			]});
+
+			this.root.sections.push(score);
+		}
+	}
+
+
+	convertStaffToPianoStaff () {
+		const score = this.root.getBlock("score");
+		if (score) {
+			const pstaff = score.findFirst(term => term instanceof ContextedMusic && term.head.cmd === "new" && term.head.args[0] === "Staff") as ContextedMusic;
+			if (pstaff) {
+				pstaff.head.args[0] = "PianoStaff";
+
+				if (pstaff.body instanceof SimultaneousList) {
+					pstaff.body.list = [].concat(...pstaff.body.list.map(term => {
+						if (term instanceof ContextedMusic) {
+							const subMusics = term.list.filter(sub => sub instanceof ContextedMusic);
+
+							return subMusics.map(music => {
+								const staff = term.clone();
+								staff.list = [
+									...term.list.filter(sub => !(sub instanceof ContextedMusic)),
+									music,
+								];
+
+								staff.head.cmd = "new";
+
+								return staff;
+							});
+						}
+						else
+							return [term];
+					}));
+				}
+			}
+		}
+	}
+
+
+	pruneStemDirections () {
+		this.root.forEachTerm(MusicBlock, block => {
+			let direction = null;
+			const redundants = [];
+
+			block.body.forEach(term => {
+				if (term instanceof StemDirection) {
+					if (term.direction === direction)
+						redundants.push(term);
+					else
+						direction = term.direction;
+				}
+				else if (term instanceof Command && term.findFirst(MusicBlock))
+					direction = null;
+			});
+
+			block.body = block.body.filter(term => !redundants.includes(term));
+		});
+	}
+
+
+	removeRepeats () {
+		this.root.forEachTerm(MusicBlock, block => block.spreadRepeatBlocks());
+	}
+
+
+	articulateMIDIOutput () {
+		const ARTICULATE_FILENAME = "articulate-lotus.ly";
+
+		this.abstractMainScore();
+		const midiScore = this.makeMIDIDedicatedScore();
+
+		if (!this.root.includeFiles.includes(ARTICULATE_FILENAME)) {
+			let pos = this.root.sections.indexOf(midiScore);
+			if (pos < 0)
+				pos = Math.min(this.root.sections.length, 3);
+			this.root.sections.splice(pos, 0, Include.create(ARTICULATE_FILENAME));
+		}
+
+		midiScore.body = midiScore.body.map(term => {
+			if (term.isMusic && !(term instanceof Command && term.cmd === "articulate"))
+				return new Command({cmd: "articulate", args: [term]});
+
+			return term;
+		});
+	}
+
+
+	removeInvalidExpressionsOnRests (): number {
+		const isInvalidPostEvent = (event: PostEvent | string): boolean =>
+			[".", "!", "_"].includes(event instanceof PostEvent ? event.arg as string : event);
+
+		let count = 0;
+		this.root.forEachTerm(MusicEvent, (term: MusicEvent) => {
+			if (term.isRest) {
+				if (term.post_events.some(isInvalidPostEvent)) {
+					term.post_events = term.post_events.filter(event => !isInvalidPostEvent(event));
+					++count;
+				}
+			}
+		});
+
+		return count;
+	}
+
+
+	abstractMainScore () {
+		const score = this.root.getBlock("score");
+		const music = score.body.find(term => term.isMusic);
+		if (music && !(music instanceof Variable)) {
+			const sectionIndex = this.root.sections.indexOf(score);
+			const assignment = new Assignment({
+				key: MAIN_SCORE_NAME,
+				value: music,
+			});
+			this.root.sections.splice(sectionIndex, 0, assignment);
+
+			score.body = score.body.map(term => term === music ? new Variable({name: MAIN_SCORE_NAME}) : term);
+		}
+	}
+
+
+	absoluteBlocksToRelative () {
+		this.root.forEachTopTerm(Assignment, assignment => {
+			if (assignment.value instanceof MusicBlock) {
+				const relative = assignment.value.absoluteToRelative();
+				if (relative)
+					assignment.value = relative;
+			}
+		});
+	}
+};

inc/lilyParser/lilyInterpreter.ts

@@ -0,0 +1,1476 @@
+
+import {romanize} from "../romanNumeral";
+import {WHOLE_DURATION_MAGNITUDE, GRACE_DURATION_FACTOR, FUNCTIONAL_VARIABLE_NAME_PATTERN, MAIN_SCORE_NAME, lcmMulti, lcm} from "./utils";
+import {parseRaw, getDurationSubdivider, MusicChunk, constructMusicFromMeasureLayout, StemDirection} from "./lilyTerms";
+import LogRecorder from "../logRecorder";
+import {StaffContext, PitchContextTable} from "../pitchContext";
+import * as idioms from "./idioms";
+import LilyDocument from "./lilyDocument";
+import * as LilyNotation from "../lilyNotation";
+
+import {
+	BaseTerm,
+	Root, Block, MusicEvent, Repeat, Relative, TimeSignature, Partial, Times, Tuplet, Grace, AfterGrace, Clef, Scheme, Include, Rest,
+	KeySignature, OctaveShift, Duration, Chord, MusicBlock, Assignment, Variable, Command, SimultaneousList, ContextedMusic, Primitive, Version,
+	ChordMode, LyricMode, ChordElement, Language, PostEvent, Transposition, ParallelMusic,
+} from "./lilyTerms";
+import {MeasureLayout, BlockMLayout, SingleMLayout} from "../measureLayout";
+
+
+
+interface DurationContextStackStatus {
+	factor?: {value: number};
+	tickBias?: number;
+	tremoloDuration?: Duration;
+};
+
+
+type MusicTransformer = (music: BaseTerm, context: TrackContext) => BaseTerm[];
+type MusicListener = (music: BaseTerm, context: TrackContext) => void;
+
+
+type ContextDict = {[key: string]: string};
+
+
+export enum TremoloType {
+	None,
+	Single,
+	Pitcher,
+	Catcher,
+};
+
+
+interface PitchContextTerm {
+	staffName: string;
+	track?: number;
+	//voiceName?: string;
+
+	tick?: number;
+	event: MusicEvent;
+
+	clef?: {
+		y: number,
+		value: number,
+	};
+	octaveShift?: number;
+	key?: number;
+	newMeasure?: boolean;
+	pitches?: ChordElement[];
+	tickBias?: number;
+	rest?: boolean;
+	tremoloType?: TremoloType;
+};
+
+
+class LilyStaffContext extends StaffContext {
+	staffTrack: number;
+	notes: LilyNotation.Note[] = [];
+
+	channelMap: number[] = [];
+
+
+	executeTerm (term: PitchContextTerm) {
+		//console.log("executeTerm:", term);
+
+		if (term.newMeasure)
+			this.resetAlters();
+
+		if (term.clef)
+			this.setClef(term.clef.y, term.clef.value);
+		if (Number.isFinite(term.octaveShift))
+			this.setOctaveShift(-term.octaveShift);
+		if (Number.isFinite(term.key)) {
+			this.resetKeyAlters();
+
+			if (term.key) {
+				const step = term.key > 0 ? 1 : -1;
+				for (let p = step; p / term.key <= 1; p += step) {
+					const index = ((step > 0 ? p - 1 : p) + 70) % 7;
+					const note = idioms.PHONETS.indexOf(idioms.FIFTH_PHONETS[index]);
+
+					this.keyAlters[note] = (this.keyAlters[note] || 0) + step;
+				}
+				this.dirty = true;
+			}
+		}
+
+		if (term.pitches) {
+			// accidental alters
+			term.pitches.forEach(pitch => {
+				const note = pitch.absoluteNotePosition;
+				const alter = this.alterOnNote(note);
+				if (pitch.alterValue !== alter) {
+					this.alters[note] = pitch.alterValue;
+					this.dirty = true;
+				}
+			});
+
+			const event = term.event;
+			const contextIndex = this.snapshot({tick: event._tick});
+
+			const implicitType = event.implicitType || (term.tremoloType ? LilyNotation.ImplicitType.Tremolo : LilyNotation.ImplicitType.None);
+
+			this.notes.push(...term.pitches.map((pitch, index) => ({
+				track: term.track,
+				channel: this.channelMap[term.track] || 0,
+				measure: event._measure,
+				start: event._tick,
+				duration: event.durationMagnitude,
+				division: event.division,
+				startTick: event._tick,
+				endTick: event._tick + event.durationMagnitude,
+				pitch: pitch.absolutePitchValue + (pitch._transposition || 0),
+				velocity: 127,
+				id: pitch.href,
+				ids: [pitch.href],
+				tied: !!pitch._tied,
+				rest: event.isRest,
+				afterGrace: !!term.tickBias,
+				implicitType,
+				staffTrack: this.staffTrack,
+				contextIndex,
+				// TODO: consider connected arpeggio & downward arpeggio
+				chordPosition: {
+					index,
+					count: term.pitches.length,
+				},
+			})));
+
+			term.pitches.forEach(pitch => {
+				const tiedParent = pitch.tiedParent;
+				if (tiedParent) {
+					const note = this.notes.find(note => note.id === tiedParent.href);
+					if (note)
+						note.ids.push(pitch.href);
+				}
+			});
+		}
+		else if (term.rest) {
+			const event = term.event;
+			const contextIndex = this.snapshot({tick: event._tick});
+
+			this.notes.push({
+				track: term.track,
+				channel: this.channelMap[term.track] || 0,
+				measure: event._measure,
+				start: event._tick,
+				duration: event.durationMagnitude,
+				startTick: event._tick,
+				endTick: event._tick + event.durationMagnitude,
+				pitch: null,
+				velocity: 0,
+				id: event.href,
+				ids: [event.href],
+				tied: false,
+				rest: true,
+				afterGrace: !!term.tickBias,
+				implicitType: event.implicitType,
+				staffTrack: this.staffTrack,
+				contextIndex,
+			});
+		}
+	}
+
+
+	get pitchContextTable (): PitchContextTable {
+		const items = this.track.contexts.map(context => ({
+			tick: context.tick,
+			endTick: null,
+			context,
+		}));
+		items.forEach((item, i) => {
+			item.endTick = (i + 1 < items.length ? items[i + 1].tick : Infinity);
+		});
+
+		return new PitchContextTable({items});
+	}
+};
+
+
+
+export class MusicTrack {
+	block: MusicBlock;
+	anchorPitch: ChordElement;
+	contextDict?: ContextDict = null;
+
+	name?: string;
+	measureHeads: number[];
+
+
+	static fromBlockAnchor (block: MusicBlock, anchorPitch: ChordElement): MusicTrack {
+		const track = new MusicTrack;
+
+		track.block = block;
+		track.anchorPitch = anchorPitch;
+
+		const context = new TrackContext(track);
+		context.execute(track.music);
+
+		return track;
+	}
+
+
+	get music (): BaseTerm {
+		if (!this.block._parent) {
+			this.block._parent = new Relative({cmd: "relative", args: this.anchorPitch ? [this.anchorPitch.clone(), this.block] : [this.block]});
+			this.block.updateChordAnchors();
+		}
+
+		return this.block._parent;
+	}
+
+
+	get noteDurationSubdivider (): number {
+		return getDurationSubdivider(this.block);
+	}
+
+
+	get durationMagnitude (): number {
+		return this.block && this.block.durationMagnitude;
+	}
+
+
+	get isLyricMode (): boolean {
+		return (this.music instanceof LyricMode) || !!this.block.findFirst(term => term instanceof LyricMode);
+	}
+
+
+	get isChordMode (): boolean {
+		return (this.music instanceof ChordMode) || !!this.block.findFirst(term => term instanceof ChordMode);
+	}
+
+
+	get measureLayoutCode (): string {
+		let code = this.block.measureLayout.code;
+		if (/^\[.*\]$/.test(code))
+			code = code.match(/\[(.*)\]/)[1];
+
+		return code;
+	}
+
+
+	transform (transformer: MusicTransformer) {
+		new TrackContext(this, {transformer}).execute(this.music);
+	}
+
+
+	clarifyDurations () {
+		this.transform(term => {
+			if (term instanceof MusicEvent) {
+				if (!term.duration)
+					term.duration = term.durationValue;
+			}
+
+			return [term];
+		});
+	}
+
+
+	splitLongRests () {
+		this.clarifyDurations();
+
+		this.transform((term, context) => {
+			if (!(term instanceof MusicEvent) || (!term.withMultiplier && !(term instanceof Rest)))
+				return [term];
+
+			const timeDenominator = context.time ? context.time.value.denominator : 4;
+			const duration = term.durationValue;
+			const denominator = Math.max(duration.denominator, timeDenominator);
+
+			const isR = !(term as Rest).isSpacer;
+
+			if (term.withMultiplier) {
+				const factor = duration.multipliers.reduce((factor, multiplier) => factor * Number(multiplier), 1);
+				if (!Number.isInteger(factor) || factor <= 0) {
+					console.warn("invalid multiplier:", factor, duration.multipliers);
+					return [term];
+				}
+
+				const event = term.clone() as MusicEvent;
+				event.duration.multipliers = [];
+
+				// break duration into multiple rest events
+				const restCount = (event.duration.magnitude / WHOLE_DURATION_MAGNITUDE) * (factor - 1) * denominator;
+				if (!Number.isInteger(restCount))
+					console.warn("Rest count is not integear:", restCount, denominator, event.duration.magnitude, factor);
+
+				const rests = Array(Math.floor(restCount)).fill(null).map(() =>
+					new Rest({name: "s", duration: new Duration({number: denominator, dots: 0})}));
+
+				return [event, ...rests];
+			}
+			else {
+				const divider = lcm(duration.subdivider, denominator);
+				const restCount = term.durationMagnitude * divider / WHOLE_DURATION_MAGNITUDE;
+				console.assert(Number.isInteger(restCount), "rest count is not an integer:", restCount);
+
+				if (isR && restCount > 1)
+					console.warn("splitLongRests: 'r' was splitted into", restCount, "parts.", term._location);
+
+				const list = Array(restCount).fill(null).map(() =>
+					new Rest({name: isR ? "r" : "s", duration: new Duration({number: divider, dots: 0})}));
+
+				if (term.post_events)
+					list[list.length - 1].post_events = term.post_events.map(e => e instanceof BaseTerm ? e.clone() : e);
+
+				return list;
+			}
+		});
+	}
+
+
+	spreadMusicBlocks (): boolean {
+		let has = false;
+
+		this.transform((term) => {
+			if (term instanceof MusicBlock) {
+				has = true;
+				return term.body;
+			}
+			else
+				return [term];
+		});
+
+		return has;
+	}
+
+
+	spreadRelativeBlocks (): boolean {
+		// check if traverse is nessary
+		if (!this.block.findFirst(Relative))
+			return false;
+
+		this.transform((term, context) => {
+			if (term instanceof Relative) {
+				if (term.music instanceof MusicBlock)
+					term.music.updateChordAnchors();
+
+				const terms = term.shiftBody(context.pitch);
+
+				// initialize anchor pitch for track head chord
+				if (!context.event || !context.event.getPreviousT(Chord)) {
+					const tempBlock = new MusicBlock({body: []});
+					tempBlock.body = terms;
+					const head = tempBlock.findFirst(Chord);
+					if (head)
+						//head._anchorPitch = this.anchorPitch;
+						head._anchorPitch = context.pitch;
+				}
+
+				return terms;
+			}
+			else
+				return [term];
+		});
+
+		return true;
+	}
+
+
+	spreadRepeatBlocks ({ignoreRepeat = true, keepTailPass = false} = {}): boolean {
+		// check if traverse is nessary
+		if (!this.block.findFirst(Repeat))
+			return false;
+
+		this.transform(term => {
+			if (term instanceof Repeat) {
+				if (!ignoreRepeat)
+					return term.getUnfoldTerms();
+				else if (keepTailPass)
+					return term.getTailPassTerms();
+				else
+					return term.getPlainTerms();
+			}
+			else if (term instanceof Variable && term.name === "lotusRepeatABA")
+				return [];
+			else
+				return [term];
+		});
+
+		return true;
+	}
+
+
+	flatten ({spreadRepeats = false} = {}) {
+		this.splitLongRests();
+		this.spreadRelativeBlocks();
+
+		if (spreadRepeats) {
+			while (this.spreadRepeatBlocks())
+				;
+
+			// expand all music blocks
+			while (this.spreadMusicBlocks());
+		}
+	}
+
+
+	sliceMeasures (start: number, count: number): MusicTrack {
+		this.flatten({spreadRepeats: true});
+
+		const context = new TrackContext(this);
+		context.pitch = this.anchorPitch;
+		this.block.updateChordAnchors();
+
+		for (const term of this.block.body) {
+			if (Number.isInteger(term._measure)) {
+				if (term._measure < start)
+					context.execute(term);
+				else
+					break;
+			}
+		}
+
+		const terms = context.declarations.concat(this.block.body.filter(term => term._measure >= start && term._measure < start + count));
+		const newBlock = MusicBlock.fromTerms(terms);
+
+		return MusicTrack.fromBlockAnchor(newBlock, context.pitch);
+	}
+
+
+	redivide () {
+		this.block.redivide({measureHeads: this.measureHeads});
+	}
+
+
+	applyMeasureLayout (layout: MeasureLayout, {flatten = true} = {}) {
+		//console.log("applyMeasureLayout:", this, layout);
+
+		if (flatten)
+			this.flatten({spreadRepeats: true});
+
+		const chunks = this.block.measureChunkMap;
+
+		// validate layout value
+		const indices = layout.serialize(LilyNotation.LayoutType.Ordinary);
+		indices.forEach(index => {
+			if (!chunks.get(index))
+				throw new Error(`applyMeasureLayout: measure[${index}] missed in chunk map.`);
+		});
+
+		// append zero-duration tail chunk, e.g. \bar "|."
+		const tailIndex = Math.max(...indices) + 1;
+		const tailChunk = chunks.get(tailIndex);
+		if (tailChunk && !tailChunk.durationMagnitude && layout instanceof BlockMLayout)
+			//layout.seq.push(SingleMLayout.from(tailIndex));
+			layout = BlockMLayout.fromSeq([...layout.seq, SingleMLayout.from(tailIndex)]);
+
+		this.block.body = constructMusicFromMeasureLayout(layout, chunks).terms;
+
+		this.redivide();
+	}
+
+
+	generateStaffTracks (): PitchContextTerm[] {
+		const pcTerms: PitchContextTerm[] = [];
+
+		let currentTerm = null;
+		const commitTerm = () => {
+			if (currentTerm) {
+				pcTerms.push(currentTerm);
+				currentTerm = null;
+			}
+		};
+		const getCurrentTerm = (staffName: string): PitchContextTerm => {
+			if (currentTerm && currentTerm.staffName !== staffName)
+				commitTerm();
+
+			if (!currentTerm)
+				currentTerm = {staffName};
+
+			return currentTerm;
+		};
+
+		let measureIndex = 0;
+
+		const listener = (term: BaseTerm, track: TrackContext) => {
+			getCurrentTerm(track.staffName).tick = term._tick;
+
+			if (term._measure !== measureIndex) {
+				getCurrentTerm(track.staffName).newMeasure = true;
+				commitTerm();
+
+				measureIndex = term._measure;
+			}
+
+			if (term instanceof Chord) {
+				const pcTerm = getCurrentTerm(track.staffName);
+				pcTerm.event = term;
+				pcTerm.pitches = term.pitchesValue.filter(pitch => pitch instanceof ChordElement) as ChordElement[];
+				pcTerm.pitches = [...pcTerm.pitches].sort((p1, p2) => p1.absolutePitchValue - p2.absolutePitchValue);
+
+				if (track.tickBias)
+					pcTerm.tickBias = track.tickBias;
+
+				pcTerm.tremoloType = track.tremoloType;
+
+				commitTerm();
+			}
+			else if (term instanceof Rest && term.name !== "s") {
+				const pcTerm = getCurrentTerm(track.staffName);
+				pcTerm.event = term;
+				pcTerm.rest = true;
+
+				commitTerm();
+			}
+			else if (term instanceof Clef) {
+				//console.log("clef:", term.clefName);
+				switch (term.clefName) {
+				case "treble":
+					// a treble (G4) on the 2nd staff line
+					getCurrentTerm(track.staffName).clef = {y: 1, value: 4};
+
+					break;
+				case "bass":
+					// a bass (F3) on the 4th staff line
+					getCurrentTerm(track.staffName).clef = {y: -1, value: -4};
+
+					break;
+				case "tenor":
+					// a tenor (C4) on the 3rd staff line
+					getCurrentTerm(track.staffName).clef = {y: 0, value: 0};
+
+					break;
+				}
+			}
+			else if (term instanceof KeySignature)
+				getCurrentTerm(track.staffName).key = term.key;
+			else if (term instanceof OctaveShift)
+				getCurrentTerm(track.staffName).octaveShift = term.value;
+		};
+		new TrackContext(this, {listener}).execute(this.music);
+
+		return pcTerms;
+	}
+};
+
+
+export class TrackContext {
+	track: MusicTrack;
+	transformer?: MusicTransformer;
+	listener?: MusicListener;
+
+	stack: DurationContextStackStatus[] = [];
+
+	// declarations
+	staff: Command = null;
+	clef: Clef = null;
+	key: KeySignature = null;
+	time: TimeSignature = null;
+	octave: OctaveShift = null;
+
+	pitch: ChordElement = null;
+
+	staffName: string = null;
+	voiceName: string = null;
+	transposition: number = 0;
+
+	// time status
+	tick: number = 0;
+	tickInMeasure: number = 0;
+	measureSpan: number = WHOLE_DURATION_MAGNITUDE;
+	measureIndex: number = 1;
+	partialDuration: Duration = null;
+	measureHeads: number[] = [0];
+
+	event: MusicEvent = null;
+	tying: MusicEvent = null;
+	staccato: boolean = false;
+	inGrace: boolean = false;
+	stemDirection: string = null;
+	beamOn: boolean = false;
+
+	tremoloType: TremoloType = TremoloType.None;
+
+
+	constructor (track = new MusicTrack, {transformer = null, listener = null, contextDict = null}:
+		{
+			transformer?: MusicTransformer,
+			listener?: MusicListener,
+			contextDict?: ContextDict,
+		} = {}) {
+		this.track = track;
+		this.track.contextDict = contextDict || this.track.contextDict;
+		this.track.measureHeads = this.measureHeads;
+
+		this.transformer = transformer;
+		this.listener = listener;
+
+		if (this.track.contextDict) {
+			this.staffName = this.track.contextDict.Staff;
+			this.voiceName = this.track.contextDict.Voice;
+		}
+		//console.debug("contextDict:", contextDict);
+	}
+
+
+	clone (): this {
+		const ctx = {...this};
+		Object.setPrototypeOf(ctx, Object.getPrototypeOf(this));
+
+		return ctx;
+	}
+
+
+	mergeParallelClones (contexts: TrackContext[]) {
+		const frontContext = contexts.reduce((front, context) => {
+			const next = !front || context.tick > front.tick ? context : front;
+			next.tying = next.tying || context.tying;
+			next.staccato = next.staccato || context.staccato;
+
+			return next;
+		}, null);
+		const lastContext = contexts[contexts.length - 1];
+
+		this.tick = frontContext.tick;
+		this.tickInMeasure = frontContext.tickInMeasure;
+		this.measureIndex = frontContext.measureIndex;
+		this.partialDuration = frontContext.partialDuration;
+		this.tying = frontContext.tying;
+		this.staccato = frontContext.staccato;
+
+		this.pitch = lastContext.pitch;
+		this.event = lastContext.event;
+	}
+
+
+	get factor (): {value: number} {
+		for (let i = this.stack.length - 1; i >= 0; i--) {
+			const status = this.stack[i];
+			if (status.factor)
+				return status.factor;
+		}
+
+		return null;
+	}
+
+
+	get tremoloDuration (): Duration {
+		for (let i = this.stack.length - 1; i >= 0; i--) {
+			const status = this.stack[i];
+			if (status.tremoloDuration)
+				return status.tremoloDuration;
+		}
+
+		return null;
+	}
+
+
+	get tickBias (): number {
+		for (let i = this.stack.length - 1; i >= 0; i--) {
+			const status = this.stack[i];
+			if (status.tickBias)
+				return status.tickBias;
+		}
+
+		return 0;
+	}
+
+
+	get measureIndexBias (): number {
+		if (this.tickInMeasure + this.tickBias < -1)
+			return -1;
+
+		return 0;
+	}
+
+
+	get factorValue (): number {
+		return this.factor && Number.isFinite(this.factor.value) ? this.factor.value : 1;
+	}
+
+
+	get currentMeasureSpan (): number {
+		return Math.round(this.partialDuration ? this.partialDuration.magnitude : this.measureSpan);
+	}
+
+
+	setPitch (pitch: ChordElement) {
+		if (!this.track.anchorPitch)
+			this.track.anchorPitch = pitch;
+
+		this.pitch = pitch;
+	}
+
+
+	newMeasure (measureSpan: number) {
+		console.assert(Number.isFinite(this.measureHeads[this.measureIndex - 1]), "invalid measureHeads at", this.measureIndex - 1, this.measureHeads);
+		this.measureHeads[this.measureIndex] = this.measureHeads[this.measureIndex - 1] + measureSpan;
+
+		++this.measureIndex;
+		this.tickInMeasure -= measureSpan;
+
+		this.partialDuration = null;
+	}
+
+
+	checkIncompleteMeasure () {
+		if (this.tickInMeasure) {
+			console.warn("incomplete measure trunated:", this.measureIndex, `${this.tickInMeasure}/${this.currentMeasureSpan}`);
+			this.newMeasure(this.tickInMeasure);
+		}
+	}
+
+
+	elapse (duration: number) {
+		const increment = duration * this.factorValue;
+
+		this.tick += increment;
+
+		this.tickInMeasure += increment;
+		while (Math.round(this.tickInMeasure) >= this.currentMeasureSpan)
+			this.newMeasure(this.currentMeasureSpan);
+	}
+
+
+	push (status: DurationContextStackStatus) {
+		this.stack.push(status);
+	}
+
+	
+	pop () {
+		this.stack.pop();
+	}
+
+
+	processGrace (music: BaseTerm, factor = GRACE_DURATION_FACTOR) {
+		// pull back grace notes' ticks
+		let events = [music];
+		if (!(music instanceof MusicEvent))
+			events = music.findAll(MusicEvent);
+
+		let tick = this.tick;
+		events.reverse().forEach(event => {
+			tick -= Math.round(event.durationMagnitude * factor * this.factorValue);
+			event._tick = tick;
+
+			event.findAll(ChordElement).forEach(note => note._tick = tick);
+		});
+	}
+
+
+	execute (term: BaseTerm) {
+		if (!term) {
+			console.warn("null term:", term);
+			return;
+		}
+
+		if (!(term instanceof BaseTerm))
+			return;
+
+		term._measure = this.measureIndex + this.measureIndexBias;
+		term._tick = this.tick;
+
+		if (term instanceof MusicEvent) {
+			term._previous = this.event;
+
+			if (term instanceof Chord) {
+				if (!this.track.anchorPitch)
+					this.track.anchorPitch = ChordElement.default.clone();
+
+				this.setPitch(term.absolutePitch);
+
+				term.pitches.forEach(pitch => {
+					this.execute(pitch);
+
+					if (pitch instanceof ChordElement)
+						pitch._transposition = this.transposition;
+				});
+
+				// update tied for ChordElement
+				// TODO: staccato trigger condition?
+				if (this.tying /*&& !this.staccato*/ && this.event && this.event instanceof Chord) {
+					const pitches = new Set(this.event.pitchElements.map(pitch => pitch.absolutePitch.pitch));
+					term.pitchElements.forEach(pitch => {
+						if (pitches.has(pitch.absolutePitch.pitch))
+							pitch._tied = this.tying;
+						//else
+						//	console.log("missed tie:", `${pitch._location.lines[0]}:${pitch._location.columns[0]}`, pitch.absolutePitch.pitch, pitches);
+					});
+
+					if (this.staccato)
+						console.warn("tie on staccato note:", term.href);
+				}
+				//console.log("chord:", term.pitches[0]);
+			}
+
+			if (term.beamOn)
+				this.beamOn = true;
+			else if (term.beamOff)
+				this.beamOn = false;
+
+			this.event = term;
+
+			this.elapse(term.durationMagnitude);
+
+			term._lastMeasure = this.tickInMeasure > 0 ? this.measureIndex : this.measureIndex - 1;
+
+			this.tying = null;
+			this.staccato = false;
+
+			if (term.isTying)
+				this.tying = term;
+			if (term.isStaccato)
+				this.staccato = true;
+		}
+		else if (term instanceof ChordElement) {
+			// ignore
+		}
+		else if (term instanceof MusicBlock) {
+			if (!this.track.block)
+				this.track.block = term;
+
+			term.updateChordAnchors();
+
+			if (this.transformer) {
+				const body = [];
+				for (const subterm of term.body) {
+					const terms = this.transformer(subterm, this);
+					terms.forEach(t => this.execute(t));
+
+					body.push(...terms);
+				}
+	
+				term.body = body;
+			}
+			else {
+				for (const subterm of term.body)
+					this.execute(subterm);
+			}
+		}
+		else if (term instanceof Command && term.cmd === "numericTimeSignature")
+			this.execute(term.args[0]);
+		else if (term instanceof TimeSignature) {
+			this.time = term;
+			this.measureSpan = term.value.value * WHOLE_DURATION_MAGNITUDE;
+		}
+		else if (term instanceof Partial)
+			this.partialDuration = term.duration;
+		else if (term instanceof Repeat) {
+			switch (term.type) {
+			case "volta":
+				this.checkIncompleteMeasure();
+
+				this.execute(term.bodyBlock);
+
+				this.checkIncompleteMeasure();
+
+				if (term.alternativeBlocks) {
+					for (const block of term.alternativeBlocks) {
+						this.execute(block);
+
+						this.checkIncompleteMeasure();
+					}
+				}
+
+				break;
+			case "tremolo":
+				this.push({factor: {value: term.times}, tremoloDuration: term.sumDuration});
+				this.tremoloType = term.singleTremolo ? TremoloType.Single : TremoloType.Pitcher;
+				this.execute(term.bodyBlock);
+				this.tremoloType = TremoloType.None;
+				this.pop();
+
+				break;
+			default:
+				console.warn("unsupported repeat type:", term.type);
+			}
+		}
+		else if (term instanceof Relative) {
+			if (term.anchor)
+				this.setPitch(term.anchor);
+
+			this.execute(term.music);
+		}
+		else if (term instanceof LyricMode) {
+			// ignore lyric mode
+		}
+		else if (term instanceof Command && term.cmd === "lyricsto") {
+			// ignore lyric mode
+		}
+		else if (term instanceof ChordMode) {
+			// ignore chord mode
+		}
+		else if (term instanceof Transposition)
+			this.transposition = term.transposition;
+		else if (term instanceof Times) {
+			this.push({factor: term.factor});
+			this.execute(term.music);
+			this.pop();
+		}
+		else if (term instanceof Tuplet) {
+			this.push({factor: term.divider.reciprocal});
+			this.execute(term.music);
+			this.pop();
+		}
+		else if (term instanceof Grace) {
+			this.inGrace = true;
+			this.push({factor: {value: 0}});
+			this.execute(term.music);
+			this.pop();
+			this.inGrace = false;
+
+			this.processGrace(term.music);
+		}
+		else if (term instanceof AfterGrace) {
+			this.execute(term.body);
+
+			this.inGrace = true;
+			this.push({factor: {value: 0}, tickBias: -term.body.durationMagnitude});
+			this.execute(term.grace);
+			this.pop();
+			this.inGrace = false;
+
+			this.processGrace(term.grace);
+		}
+		else if (term instanceof Clef)
+			this.clef = term;
+		else if (term instanceof KeySignature)
+			this.key = term;
+		else if (term instanceof OctaveShift)
+			this.octave = term;
+		else if (term instanceof Command && term.cmd === "change") {
+			const pair = term.getAssignmentPair();
+			if (pair) {
+				switch (pair.key) {
+				case "Staff":
+					this.staffName = pair.value.toString();
+					this.staff = term;
+
+					break;
+				case "Voice":
+					this.voiceName = pair.value.toString();
+
+					break;
+				}
+			}
+		}
+		else if (term instanceof Primitive) {
+			if (term.exp === "~")
+				this.tying = this.event;
+		}
+		else if (term instanceof PostEvent) {
+			if (term.isStaccato)
+				this.staccato = true;
+		}
+		else if (term instanceof SimultaneousList) {
+			const contexts: TrackContext[] = [];
+			let lastContext = this;
+			for (const subterm of term.list) {
+				const context = this.clone();
+				context.pitch = lastContext.pitch;
+				context.event = lastContext.event;
+
+				context.execute(subterm);
+				contexts.push(context);
+				lastContext = context;
+			}
+
+			this.mergeParallelClones(contexts);
+		}
+		else if (term instanceof ContextedMusic) {
+			// TODO: process contextDict
+
+			this.execute(term.body);
+		}
+		else if (term instanceof StemDirection)
+			this.stemDirection = term.direction;
+		else {
+			if (term.isMusic)
+				console.warn("[TrackContext]	unexpected music term:", term);
+		}
+
+		if (this.listener)
+			this.listener(term, this);
+
+		if (term instanceof MusicEvent && this.tremoloType === TremoloType.Pitcher)
+			this.tremoloType = TremoloType.Catcher;
+	}
+
+
+	get declarations (): BaseTerm[] {
+		return [this.staff, this.clef, this.key, this.time, this.octave].filter(term => term);
+	}
+};
+
+
+class MusicPerformance {
+	staffNames: string[] = [];
+	musicTracks: MusicTrack[] = [];
+
+
+	get mainTrack (): MusicTrack {
+		// find the longest track
+		const trackPrior = (track: MusicTrack, index: number): number => -track.block.durationMagnitude + index * 1e-3;
+		const priorTracks = this.musicTracks
+			.filter(track => track.block._parent && !track.isChordMode && !track.isLyricMode)
+			.map((track, index) => ({track, index}))
+			.sort((t1, t2) => trackPrior(t1.track, t1.index) - trackPrior(t2.track, t2.index));
+
+		return priorTracks[0] ? priorTracks[0].track : null;
+	}
+
+
+	get trackNames (): string[] {
+		return this.musicTracks.map(track => `${track.contextDict.Staff}:${track.contextDict.Voice}`);
+	}
+
+
+	get trackContextDicts (): ContextDict[] {
+		const dicts = this.musicTracks.map(track => track.contextDict);
+		dicts.unshift(undefined);	// zero placeholder for track index from 1 in notation & SheetDocument
+
+		return dicts;
+	}
+
+
+	get trackInstruments (): string[] {
+		return this.musicTracks.map(track => {
+			const instrumentKey = Object.keys(track.contextDict).find(key => /\.instrumentName/.test(key));
+			if (instrumentKey)
+				return track.contextDict[instrumentKey];
+
+			return null;
+		});
+	}
+
+
+	get instrumentList (): string[] {
+		return Array.from(new Set(this.trackInstruments));
+	}
+
+
+	get channelMap (): number[] {
+		const instrumentList = this.instrumentList;
+		const channels = this.trackInstruments.map(instrument => instrumentList.indexOf(instrument) + 1);
+		channels.unshift(0);
+
+		return channels;
+	}
+
+
+	get measureLayoutCode (): string {
+		return this.mainTrack && this.mainTrack.measureLayoutCode;
+	}
+
+
+	applyMeasureLayout (layout: MeasureLayout) {
+		this.musicTracks.forEach(track => track.applyMeasureLayout(layout));
+	}
+
+
+	getNotation ({logger = new LogRecorder()} = {}): LilyNotation.Notation {
+		const pcTerms: PitchContextTerm[] = [].concat(...this.musicTracks.map((track, i) =>
+			track.generateStaffTracks().map(term => ({track: i + 1, ...term}))));
+		//console.log("pcTerms:", pcTerms);
+
+		const termsToContexts = (staffTerms: PitchContextTerm[], trackIndex: number): LilyStaffContext => {
+			staffTerms.forEach(term => {
+				if (term.event)
+					term.tick = term.event._tick;
+			});
+			staffTerms.sort((t1, t2) => t1.tick - t2.tick);
+
+			const context = new LilyStaffContext({logger});
+			context.staffTrack = trackIndex;
+			context.channelMap = this.channelMap;
+
+			logger.append("staffTerms", staffTerms);
+			//console.debug("staffTerms:", staffTerms);
+			staffTerms.forEach(term => context.executeTerm(term));
+
+			return context;
+		};
+
+		const staffContexts: LilyStaffContext[] = [];
+		if (this.staffNames.length) {
+			this.staffNames.forEach((name, trackIndex) => {
+				const staffTerms = pcTerms.filter(term => term.staffName === name);
+				staffContexts.push(termsToContexts(staffTerms, trackIndex));
+			});
+		}
+		else
+			staffContexts.push(termsToContexts(pcTerms, 0));
+
+		const notes = []
+			.concat(...staffContexts.map(context => context.notes))
+			.sort((n1, n2) => n1.startTick - n2.startTick);
+
+		// append duration of tied notes to root note
+		const pitchMap = {};
+		notes.forEach(note => {
+			if (note.tied) {
+				const root = pitchMap[note.pitch];
+				if (root) {
+					root.endTick = Math.max(root.endTick, note.endTick);
+					root.duration = root.endTick - root.startTick;
+				}
+			}
+			else
+				pitchMap[note.pitch] = note;
+		});
+
+		const pitchContextGroup = staffContexts.map(context => context.pitchContextTable);
+
+		const mainTrack = this.mainTrack;
+
+		const measureHeads = mainTrack && mainTrack.measureHeads;
+		const measureLayout = mainTrack && mainTrack.block.measureLayout;
+
+		return LilyNotation.Notation.fromAbsoluteNotes(notes, measureHeads, {pitchContextGroup, measureLayout, trackNames: this.trackNames});
+	}
+
+
+	getNoteDurationSubdivider (): number {
+		const subdivider = lcmMulti(...this.musicTracks.map(track => track.noteDurationSubdivider));
+
+		return subdivider;
+	}
+
+
+	sliceMeasures (start: number, count: number) {
+		this.musicTracks = this.musicTracks.map(track => {
+			const newTrack = track.sliceMeasures(start, count);
+			newTrack.name = track.name;	// inherit name
+
+			return newTrack;
+		});
+	}
+};
+
+
+
+export default class LilyInterpreter {
+	variableTable: Map<string, BaseTerm> = new Map();
+
+	// temporary status
+	musicTracks: MusicTrack[] = [];
+	staffNames: string[] = [];
+	musicTrackIndex: number = 0;
+	musicPerformance: MusicPerformance;
+	mainPerformance: MusicPerformance;
+
+	version: Version = null;
+	language: Language = null;
+	header: Block = null;
+	includeFiles: Set<string> = new Set;
+	statements: BaseTerm[] = [];
+	paper: Block = null;
+	layout: Block = null;
+	scores: Block[] = [];
+
+	layoutMusic: MusicPerformance;
+	midiMusic: MusicPerformance;
+
+	functionalCommand?: Variable;
+
+	reservedVariables: Set<string> = new Set();
+
+
+	static trackName (index: number): string {
+		return `Voice_${romanize(index)}`;
+	};
+
+
+	/*eval (term: BaseTerm): BaseTerm {
+		return this.execute(term.clone());
+	}*/
+
+
+	get mainScore (): BaseTerm {
+		return this.variableTable.get(MAIN_SCORE_NAME);
+	};
+
+
+	interpretMusic (music: BaseTerm, contextDict: ContextDict): Variable {
+		//console.log("interpretMusic:", music);
+		const context = new TrackContext(undefined, {contextDict});
+		//context.execute(music.clone());
+		context.execute(music);
+
+		context.track.spreadRelativeBlocks();
+		this.musicTracks.push(context.track);
+
+		const varName = LilyInterpreter.trackName(++this.musicTrackIndex);
+
+		context.track.name = varName;
+
+		return new Variable({name: varName});
+	}
+
+
+	interpretDocument (doc: LilyDocument): this {
+		if (doc.reservedVariables)
+			this.appendReservedVariables(doc.reservedVariables);
+
+		this.execute(doc.root);
+
+		return this;
+	}
+
+
+	createMusicPerformance () {
+		if (this.musicTracks.length) {
+			if (!this.musicPerformance)
+				this.musicPerformance = new MusicPerformance();
+
+			this.staffNames.forEach(name => {
+				if (!this.musicPerformance.staffNames.some(sn => sn === name))
+					this.musicPerformance.staffNames.push(name);
+				else if (!name)
+					console.warn("[LilyInterpreter]	Multiple empty context staff name may cause error pitchContextTable:", this.musicPerformance.staffNames);
+			});
+			this.musicTracks.forEach(track => this.musicPerformance.musicTracks.push(track));
+
+			this.staffNames = [];
+			this.musicTracks = [];
+		}
+	}
+
+
+	execute (term: BaseTerm, {execMusic = false, contextDict = {}}: {execMusic?: boolean, contextDict?: ContextDict} = {}): BaseTerm {
+		if (!term)
+			return term;
+
+		if (this.functionalCommand && term.isMusic) {
+			term._functional = this.functionalCommand.name;
+			this.functionalCommand = null;
+		}
+
+		if (term instanceof Root) {
+			for (const section of term.sections) {
+				const sec = this.execute(section, {execMusic: true});
+				if (sec instanceof Version)
+					this.version = sec;
+				else if (sec instanceof Language)
+					this.language = sec;
+				else if (sec instanceof Scheme)
+					this.statements.push(sec);
+				else if (sec instanceof Block) {
+					switch (sec.head) {
+					case "\\header":
+						this.header = sec;
+
+						break;
+					case "\\paper":
+						this.paper = sec;
+
+						break;
+					case "\\layout":
+						this.layout = sec;
+
+						break;
+					case "\\score":
+						this.scores.push(sec);
+
+						break;
+					}
+				}
+			}
+
+			this.createMusicPerformance();
+
+			if (this.musicPerformance) {
+				this.layoutMusic = this.musicPerformance;
+				this.midiMusic = this.musicPerformance;
+
+				this.musicPerformance = null;
+			}
+		}
+		else if (term instanceof Assignment) {
+			if (term.key) {
+				const name = term.key as string;
+				const isMainScore = name === MAIN_SCORE_NAME;
+				if (isMainScore)
+					this.musicPerformance = null;
+
+				const value = this.execute(term.value, {execMusic: isMainScore});
+
+				this.variableTable.set(name, value);
+
+				if (isMainScore)
+					this.mainPerformance = this.musicPerformance;
+			}
+		}
+		else if (term instanceof Block) {
+			switch (term.head) {
+			case "\\score":
+				const body = term.body.map(subterm => this.execute(subterm, {execMusic: true}));
+
+				this.musicPerformance = null;
+
+				return new Block({
+					block: term.block,
+					head: term.head,
+					body,
+				});
+			case "\\layout":
+				this.layoutMusic = this.musicPerformance;
+
+				break;
+			case "\\midi":
+				this.midiMusic = this.musicPerformance;
+
+				break;
+			}
+		}
+		else if (term instanceof Variable) {
+			const result = this.variableTable.get(term.name);
+			if (!result) {
+				if (FUNCTIONAL_VARIABLE_NAME_PATTERN.test(term.name)) {
+					this.functionalCommand = term;
+
+					return term;
+				}
+				else if (this.reservedVariables.has(term.name)) {
+					// ignore reserved variables
+				}
+				else
+					console.warn("uninitialized variable is referred:", term);
+			}
+
+			if (term.name === MAIN_SCORE_NAME) {
+				this.musicPerformance = this.mainPerformance;
+
+				return term;
+			}
+
+			return this.execute(result, {execMusic, contextDict});
+		}
+		else if (term instanceof MusicBlock) {
+			const result = new MusicBlock({
+				_parent: term._parent,
+				_functional: term._functional,
+				body: term.body.map(subterm => this.execute(subterm)).filter(Boolean),
+			});
+
+			this.functionalCommand = null;
+
+			if (execMusic) {
+				const variable = this.interpretMusic(result, contextDict);
+				return new MusicBlock({body: [variable]});
+			}
+
+			return result;
+		}
+		else if (term instanceof SimultaneousList) {
+			const list = term.list.map(subterm => this.execute(subterm, {execMusic, contextDict})).filter(term => term);
+			this.createMusicPerformance();
+
+			return new SimultaneousList({list});
+		}
+		else if (term instanceof ContextedMusic) {
+			if (term.contextDict && typeof term.contextDict.Staff === "string")
+				this.staffNames.push(term.contextDict.Staff);
+
+			return new ContextedMusic({
+				head: this.execute(term.head),
+				lyrics: this.execute(term.lyrics),
+				body: this.execute(term.body, {execMusic, contextDict: {...contextDict, ...term.contextDict}}),
+			});
+		}
+		else if (term instanceof ParallelMusic) {
+			term.voices.forEach(voice => {
+				const block = new MusicBlock({
+					body: MusicChunk.join(voice.body),
+				});
+
+				const value = this.execute(block);
+				this.variableTable.set(voice.name, value);
+			});
+		}
+		else if (term instanceof Include)
+			this.includeFiles.add(term.filename);
+		else if (term instanceof Command) {
+			switch (term.cmd) {
+			case "set":
+				if (term.args[0] instanceof Assignment) {
+					const assign = term.args[0];
+					contextDict[assign.key.toString()] = assign.value.toString();
+				}
+
+				break;
+			}
+
+			return parseRaw({proto: term.proto, cmd: term.cmd, args: term.args.map(arg => this.execute(arg, {execMusic, contextDict}))});
+		}
+
+		return term;
+	}
+
+
+	updateTrackAssignments () {
+		if (this.layoutMusic)
+			this.layoutMusic.musicTracks.forEach(track => this.variableTable.set(track.name, track.music));
+
+		if (this.midiMusic && this.midiMusic !== this.layoutMusic)
+			this.midiMusic.musicTracks.forEach(track => this.variableTable.set(track.name, track.music));
+
+		// update main score variable order in table
+		const mainScore = this.mainScore;
+		if (mainScore) {
+			this.variableTable.delete(MAIN_SCORE_NAME);
+			this.variableTable.set(MAIN_SCORE_NAME, mainScore);
+		}
+	}
+
+
+	toDocument (): LilyDocument {
+		this.updateTrackAssignments();
+
+		const variables = [].concat(...[this.paper, this.layout, ...this.scores, this.mainScore].filter(block => block).map(block => block.findAll(Variable).map(variable => variable.name)));
+		const variablesUnique = Array.from(new Set(variables));
+
+		// sort variables by order in variable table
+		const vars = [...this.variableTable.keys()];
+		variablesUnique.sort((v1, v2) => vars.indexOf(v1) - vars.indexOf(v2));
+
+		const assignments = variablesUnique.filter(name => this.variableTable.get(name)).map(name => new Assignment({key: name, value: this.variableTable.get(name)}));
+		const includes = Array.from(this.includeFiles).map(filename => Include.create(filename));
+
+		const root = new Root({sections: [
+			this.version,
+			this.language,
+			this.header,
+			...includes,
+			...this.statements,
+			this.paper,
+			this.layout,
+			...assignments,
+			...this.scores,
+		].filter(section => section)});
+
+		const doc = new LilyDocument(root);
+		doc.reservedVariables = this.reservedVariables;
+
+		return doc;
+	}
+
+
+	sliceMeasures (start: number, count: number) {
+		if (this.layoutMusic)
+			this.layoutMusic.sliceMeasures(start, count);
+
+		if (this.midiMusic && this.midiMusic !== this.layoutMusic)
+			this.midiMusic.sliceMeasures(start, count);
+	}
+
+
+	addIncludeFile (filename: string) {
+		this.includeFiles.add(filename);
+	}
+
+
+	appendReservedVariables (names: Iterable<string>) {
+		for (const name of names)
+			this.reservedVariables.add(name);
+	}
+
+
+	getNotation ({logger = new LogRecorder()} = {}): LilyNotation.Notation {
+		if (this.midiMusic)
+			return this.midiMusic.getNotation({logger});
+
+		return null;
+	}
+};

inc/lilyParser/lilyTerms.ts

@@ -0,0 +1,2991 @@
+
+import {WHOLE_DURATION_MAGNITUDE, FractionNumber, lcmMulti, gcd, MAIN_SCORE_NAME} from "./utils";
+import * as idioms from "./idioms";
+import {LILYPOND_VERSION} from "../constants";
+import * as measureLayout from "../measureLayout";
+import ImplicitType from "../lilyNotation/implicitType";
+import pick from "../pick";
+
+
+
+interface Location {
+	lines: [number, number];
+	columns: [number, number];
+};
+
+
+abstract class Locator {
+	location: Location;
+
+
+	constructor (term: BaseTerm) {
+		term._location = term._location || {lines: [0, 0], columns: [0, 0]};
+		this.location = term._location;
+	}
+
+	abstract set (line: number, column: number): void;
+};
+
+
+class OpenLocator extends Locator {
+	set (line: number, column: number) {
+		this.location.lines[0] = line;
+		this.location.columns[0] = column;
+	}
+};
+
+
+class CloseLocator extends Locator {
+	set (line: number, column: number) {
+		this.location.lines[1] = line;
+		this.location.columns[1] = column;
+	}
+};
+
+
+// concat array of array
+const cc = <T>(arrays: T[][]): T[] => [].concat(...arrays);
+
+
+export class MusicChunk {
+	parent: MusicBlock;
+	terms: BaseTerm[];
+
+
+	static join (chunks: MusicChunk[]): BaseTerm[] {
+		return cc(chunks.map((chunk, i) => i === chunks.length - 1 ? chunk.terms : [...chunk.terms, new Divide({})]));
+	}
+
+
+	constructor (parent: MusicBlock, terms: BaseTerm[] = []) {
+		this.parent = parent;
+		this.terms = terms;
+	}
+
+
+	push (term: BaseTerm) {
+		this.terms.push(term);
+	}
+
+
+	get size () {
+		return this.terms.length;
+	}
+
+
+	get durationMagnitude () {
+		return this.terms.reduce((magnitude, term) => magnitude + term.durationMagnitude, 0);
+	}
+};
+
+
+interface MusicVoice {
+	name?: string;
+	body: MusicChunk[];
+};
+
+
+type MusicChunkMap = Map<number, MusicChunk>;
+
+
+const isNullItem = item => item === "" || item === undefined || item === null || (Array.isArray(item) && !item.length);
+const compact = items => cc(items.map((item, index) => isNullItem(item) ? [] : [index > 0 ? "\b" : null, item]));
+
+
+export const getDurationSubdivider = (term: BaseTerm): number => {
+	if (term instanceof MusicEvent) {
+		if (!(term instanceof Rest) || !term.isSpacer)
+			return term.durationValue.subdivider;
+	}
+	else if (term instanceof MusicBlock)
+		return lcmMulti(...term.body.map(getDurationSubdivider));
+	else if (term instanceof MusicChunk)
+		return lcmMulti(...term.terms.map(getDurationSubdivider));
+	else if ((term instanceof Times) || (term instanceof Tuplet)) {
+		const divider = term instanceof Tuplet ? term.divider : term.factor.reciprocal;
+		divider.numerator *= getDurationSubdivider(term.music);
+
+		return divider.reduced.numerator;
+	}
+	else if (term instanceof Repeat)
+		return getDurationSubdivider(term.bodyBlock);
+	else if (term instanceof Relative)
+		return getDurationSubdivider(term.music);
+	else if (term.isMusic)
+		console.warn("[getDurationSubdivider]	unexpected music term:", term);
+
+	return 1;
+};
+
+
+export const constructMusicFromMeasureLayout = (layout: measureLayout.MeasureLayout, chunks: MusicChunkMap): MusicChunk => {
+	const joinMeasureSeq = (seq: measureLayout.MeasureSeq): BaseTerm[] => MusicChunk.join(seq.map(sublayout => constructMusicFromMeasureLayout(sublayout, chunks)));
+
+	if (layout instanceof measureLayout.SingleMLayout) {
+		const chunk = chunks.get(layout.measure);
+		console.assert(!!chunk, "no chunk for measure:", layout.measure);
+
+		return chunk;
+	}
+	else if (layout instanceof measureLayout.BlockMLayout) {
+		const terms = joinMeasureSeq(layout.seq);
+
+		return new MusicChunk(null, terms);
+	}
+	else if (layout instanceof measureLayout.VoltaMLayout) {
+		const bodyTerms = joinMeasureSeq(layout.body);
+		const alternative = layout.alternates && layout.alternates.map(alternate => new MusicBlock({body: joinMeasureSeq(alternate)}));
+
+		const repeat = Repeat.createVolta(layout.times.toString(), new MusicBlock({body: bodyTerms}), alternative);
+
+		return new MusicChunk(null, [repeat]);
+	}
+	else if (layout instanceof measureLayout.ABAMLayout) {
+		const mainList = constructMusicFromMeasureLayout(layout.main, chunks);
+		const main = mainList.terms.length === 1 ? mainList.terms[0] : new MusicBlock({body: mainList.terms});
+		const restTerms = joinMeasureSeq(layout.rest);
+
+		const block = new MusicBlock({body: [main, ...restTerms]});
+
+		return new MusicChunk(null, [new Variable({name: "lotusRepeatABA"}), block]);
+	}
+};
+
+
+export class BaseTerm {
+	_location?: Location;
+	_measure?: number;
+	_tick?: number;
+	_previous?: BaseTerm;
+	_anchorPitch?: ChordElement;
+	_parent?: BaseTerm;
+
+	_headComment: Comment;
+	_tailComment: Comment;
+
+	// lotus extensional function modifier
+	_functional: string;
+
+
+	constructor (data: object) {
+		//Object.assign(this, data);
+		for (const key in data) 
+			this[key] = parseRaw(data[key]);
+	}
+
+
+	serialize (): any[] {
+		console.warn("unimplemented serilization:", this);
+		return [];
+	}
+
+
+	join (): string {
+		let words = this.serialize().filter(word => ["string", "number"].includes(typeof word)).map(word => word.toString()) as string[];
+		words = words.filter((word, i) => !(i && words[i - 1] === "\n" && word === "\n"));
+
+		let indent = 0;
+		const result: string[] = [];
+
+		const pop = char => {
+			if (!char || result[result.length - 1] === char) {
+				result.pop();
+				return true;
+			}
+		};
+
+		for (const word of words) {
+			switch (word) {
+			case "\b":
+				// remove last space
+				pop(" ");
+				continue;
+
+			case "\b\n":
+				// remove last newline
+				while (pop("\t")) {}
+				pop("\n");
+				continue;
+
+			case "\n":
+				// no space at line tail
+				pop(" ");
+			}
+
+			if (/^(\}|>>)/.test(word))
+				pop("\t"); // remove the last tab
+
+			result.push(word);
+
+			if (/\n$/.test(word)) {
+				if (/(\{|<<)\n$/.test(word))
+					++indent;
+				else if (/^(\}|>>)/.test(word)) 
+					--indent;
+
+				if (indent)
+					result.push(...Array(indent).fill("\t"));
+			}
+			else
+				result.push(" ");
+		}
+
+		return result.join("");
+	}
+
+
+	relocate (source: string = this.join()) {
+		const words = this.serialize()
+			.filter(word => word !== null && word !== undefined
+				&& (typeof word !== "string" || (/\S/.test(word) && !word.includes("\b"))))
+			.map(word => typeof word === "string" ? word.replace(/\n/g, "") : word);
+
+		const chars = source.split("");
+		let line = 1;
+		let column = 0;
+
+		let wordIndex = 0;
+
+		for (let i = 0; i < chars.length; ++i) {
+			if (wordIndex >= words.length)
+				break;
+
+			const char = chars[i];
+
+			switch (char) {
+			case "\n":
+				++line;
+				column = 0;
+
+				break;
+			case " ":
+			case "\t":
+				++column;
+
+				break;
+			default:
+				let word = words[wordIndex];
+				while (word instanceof Locator) {
+					word.set(line, column);
+
+					++wordIndex;
+					word = words[wordIndex];
+				}
+
+				if (wordIndex >= words.length)
+					break;
+
+				word = word.toString();
+				if (char === word[0]) {
+					i += word.length - 1;
+					column += word.length;
+					++wordIndex;
+				}
+				else {
+					//debugger;
+					throw new Error(`unexpected char in source: [${i}]'${char}', expect: ${word}`);
+				}
+			}
+		}
+	}
+
+
+	clone (): this {
+		return parseRaw(JSON.parse(JSON.stringify(this)));
+	}
+
+
+	get entries (): BaseTerm[] {
+		return null;
+	}
+
+
+	get isMusic (): boolean {
+		return false;
+	}
+
+
+	get musicChunks (): MusicChunk[] {
+		if (!this.isMusic || !this.entries)
+			return [];
+
+		return [].concat(...this.entries.map(entry => entry.musicChunks));
+	}
+
+
+	get measures (): number[] {
+		const indices = [this._measure].concat(...(this.entries || []).map(entry => entry.measures)).filter(index => Number.isInteger(index));
+
+		return Array.from(new Set(indices));
+	}
+
+
+	get durationMagnitude (): number {
+		return 0;
+	}
+
+
+	get proto () {
+		return termProtoMap.get(Object.getPrototypeOf(this));
+	}
+
+
+	get href (): string {
+		if (this._location)
+			return `${this._location.lines[0]}:${this._location.columns[0]}:${this._location.columns[1]}`;
+
+		return null;
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		return null;
+	}
+
+
+	getField (key): any {
+		console.assert(!!this.entries, "[BaseTerm.getField] term's entries is null:", this);
+
+		for (const entry of this.entries) {
+			const result = entry.query(key);
+			if (result)
+				return result;
+		}
+	}
+
+
+	query (key: string): any {
+		void(key);
+		//console.warn("term.query not implemented:", this);
+	}
+
+
+	appendAssignment (key, value) {
+		console.assert(!!this.entries, "no entries on this term.");
+
+		const assign = this.getField(key);
+		if (assign)
+			assign.value = value;
+		else {
+			this.entries.push(parseRaw({
+				proto: "Assignment",
+				key,
+				value: value,
+			}));
+		}
+	}
+
+
+	findFirst (condition: Function): BaseTerm {
+		if (!this.entries)
+			return null;
+
+		if (BaseTerm.isPrototypeOf(condition)) {
+			const termClass = condition;
+			condition = term => term instanceof termClass;
+		}
+	
+		for (const entry of this.entries) {
+			if (condition(entry))
+				return entry;
+	
+			if (entry instanceof BaseTerm) {
+				const result = entry.findFirst(condition);
+				if (result)
+					return result;
+			}
+		}
+	}
+
+
+	findLast (condition: any): BaseTerm {
+		if (!this.entries)
+			return null;
+
+		if (BaseTerm.isPrototypeOf(condition)) {
+			const termClass = condition;
+			condition = term => term instanceof termClass;
+		}
+	
+		const reversedEntries = [...this.entries];
+		reversedEntries.reverse();
+
+		for (const entry of reversedEntries) {
+			if (condition(entry))
+				return entry;
+	
+			if (entry instanceof BaseTerm) {
+				const result = entry.findLast(condition);
+				if (result)
+					return result;
+			}
+		}
+	}
+
+
+	findAll (condition: any): any[] {
+		if (!this.entries)
+			return [];
+
+		if (BaseTerm.isPrototypeOf(condition)) {
+			const termClass = condition;
+			condition = term => term instanceof termClass;
+		}
+
+		const result = [];
+
+		for (const entry of this.entries) {
+			if (condition(entry))
+				result.push(entry);
+	
+			if (entry instanceof BaseTerm)
+				result.push(...entry.findAll(condition));
+		}
+
+		return result;
+	}
+
+
+	forEachTerm (termClass, handle) {
+		if (!this.entries)
+			return;
+
+		for (const entry of this.entries) {
+			if (entry instanceof termClass)
+				handle(entry);
+
+			if (entry instanceof BaseTerm)
+				entry.forEachTerm(termClass, handle);
+		}
+	}
+
+
+	forEachTopTerm (termClass, handle) {
+		if (!this.entries)
+			return;
+
+		for (const entry of this.entries) {
+			if (entry instanceof termClass)
+				handle(entry);
+			else if (entry instanceof BaseTerm)
+				entry.forEachTopTerm(termClass, handle);
+		}
+	}
+
+
+	toJSON () {
+		// exlude meta fields in JSON
+		const fields = Object.keys(this).filter(key => !/^_/.test(key));
+		const data = pick(this, fields);
+
+		Object.entries(data).forEach(([key, value]) => {
+			if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof BaseTerm))
+				data[key] = {proto: "_PLAIN", ...value};
+		});
+
+		return {
+			proto: this.proto,
+			...data,
+		};
+	}
+
+
+	static isTerm (x): boolean {
+		return typeof x === "object" && x instanceof BaseTerm;
+	}
+
+
+	static optionalSerialize (item: any): any[] {
+		//return BaseTerm.isTerm(item) ? (item as BaseTerm).serialize() : (item === undefined ? [] : [item]);
+		if (!BaseTerm.isTerm(item))
+			return item === undefined ? [] : [item];
+
+		return [
+			...BaseTerm.optionalSerialize(item._headComment),
+			...item.serialize(),
+			...(item._tailComment ? ["\b\n", "\t"] : []),
+			...BaseTerm.optionalSerialize(item._tailComment),
+		];
+	}
+
+
+	static serializeScheme (item: any): any[] {
+		if (typeof item === "boolean")
+			item = item ? "#t" : "#f";
+
+		return BaseTerm.optionalSerialize(item);
+	}
+}
+
+
+export class Root extends BaseTerm {
+	sections: BaseTerm[];
+
+
+	serialize () {
+		return cc(this.sections.map(section => [...BaseTerm.optionalSerialize(section), "\n\n"]));
+	}
+
+
+	get entries (): BaseTerm[] {
+		return this.sections;
+	}
+
+
+	getBlock (head): Block {
+		return this.entries.find((entry: any) => entry.head === head || (entry.head === "\\" + head)) as Block;
+	}
+
+
+	get includeFiles (): string[] {
+		return this.sections.filter(section => section instanceof Include).map((include: Include) => include.filename);
+	}
+
+
+	static priorityForSection (term: BaseTerm): number {
+		if (term instanceof Version)
+			return 0;
+
+		if (term instanceof Language)
+			return 1;
+
+		if (term instanceof Scheme)
+			return 3;
+
+		if (term instanceof Assignment)
+			return 7;
+
+		if (term instanceof Block) {
+			switch (term.head) {
+			case "\\header":
+				return 2;
+
+			case "\\paper":
+				return 4;
+
+			case "\\layout":
+				return 5;
+
+			case "\\score":
+				return 10;
+			}
+		}
+
+		return Infinity;
+	}
+
+
+	reorderSections () {
+		this.sections.sort((s1, s2) => Root.priorityForSection(s1) - Root.priorityForSection(s2));
+	}
+};
+
+
+export class Primitive extends BaseTerm {
+	exp: string | number;
+
+
+	serialize () {
+		return [this.exp];
+	}
+};
+
+
+export class LiteralString extends BaseTerm {
+	exp: string
+
+
+	static fromString (content: string): LiteralString {
+		return new LiteralString({exp: JSON.stringify(content)});
+	}
+
+
+	serialize () {
+		return [this.exp];
+	}
+
+
+	toString () {
+		try {
+			return eval(this.exp);
+		}
+		catch (err) {
+			console.warn("invalid lilypond string exp:", this.exp);
+			return this.exp;
+		}
+	}
+};
+
+
+export class Command extends BaseTerm {
+	cmd: string;
+	args: any[];
+
+
+	static createSet (key: string|BaseTerm, value: BaseTerm): Command {
+		return new Command({cmd: "set", args: [new Assignment({key, value})]});
+	}
+
+
+	constructor (data) {
+		super(data);
+
+		this.args.forEach(term => {
+			if (term instanceof MusicBlock || term instanceof Block)
+				term._parent = this;
+		});
+	}
+
+
+	serialize () {
+		return [
+			"\\" + this.cmd,
+			...[].concat(...this.args.map(BaseTerm.optionalSerialize)),
+			["break", "pageBreak", "overrideProperty"].includes(this.cmd) ? "\n" : null,
+		];
+	}
+
+
+	get entries () {
+		return this.args.filter(arg => arg instanceof BaseTerm);
+	}
+
+
+	get isMusic (): boolean {
+		return this.args.some(arg => arg.isMusic);
+	}
+
+
+	get musicChunks (): MusicChunk[] {
+		if (this.cmd === "alternative")
+			return [].concat(...this.args[0].body.map(term => term.musicChunks));
+
+		return [].concat(...this.entries.map(entry => entry.musicChunks));
+	}
+
+
+	get isRepeatWithAlternative () {
+		return this.cmd === "repeat"
+			&& this.args[2] instanceof MusicBlock
+			&& this.args[3]
+			&& this.args[3].cmd === "alternative";
+	}
+
+
+	get durationMagnitude (): number {
+		switch (this.cmd) {
+		// TODO: refine this in Times
+		case "times": {
+			const factor = eval(this.args[0]);
+			return this.args[1].durationMagnitude * factor;
+		}
+
+		// TODO: refine this in Tuplet
+		case "tuplet": {
+			const factor = 1 / eval(this.args[0]);
+			return this.args[this.args.length - 1].durationMagnitude * factor;
+		}
+
+		case "afterGrace":
+			return this.args[0].durationMagnitude;
+
+		default:
+			if (this instanceof Grace)
+				return 0;
+
+			return this.args.filter(arg => arg instanceof BaseTerm).reduce((magnitude, term) => magnitude + term.durationMagnitude, 0);
+		}
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		const args = [...this.args].reverse();
+		for (const arg of args) {
+			const layout = arg instanceof BaseTerm && arg.measureLayout;
+			if (layout)
+				return layout;
+		}
+
+		return null;
+	}
+
+
+	getAssignmentPair (): {key: any, value: any} {
+		if (this.args[0] instanceof Assignment)
+			return {key: this.args[0].key, value: this.args[0].value};
+
+		if (this.args[1] instanceof Assignment)
+			return {key: this.args[0], value: this.args[1].value};
+
+		if (typeof this.args[0] === "string")
+			return {key: this.args[0], value: ""};
+
+		return null;
+	}
+};
+
+
+export class Variable extends Command {
+	name: string
+
+
+	constructor ({name}) {
+		super({cmd: name, args: []});
+
+		this.name = name;
+	}
+
+
+	toJSON (): any {
+		return {
+			proto: this.proto,
+			name: this.name,
+		};
+	}
+
+
+	queryValue (dict: BaseTerm): any {
+		const field = dict.getField(this.name);
+
+		return field && field.value;
+	}
+
+
+	get isMusic (): boolean {
+		if ([MAIN_SCORE_NAME].includes(this.name))
+			return true;
+
+		return false;
+	}
+};
+
+
+export class MarkupCommand extends Command {
+	toString () {
+		const strs = [];
+		this.forEachTerm(LiteralString, term => strs.push(term.toString()));
+
+		return strs.join("\n");
+	}
+};
+
+
+export class Repeat extends Command {
+	static createVolta (times: string, body: MusicBlock, alternative?: MusicBlock[]): Repeat {
+		const args: any[] = [
+			"volta",
+			times,
+			body,
+		];
+
+		if (alternative) {
+			args.push(new Command({
+				cmd: "alternative",
+				args: [new MusicBlock({body: alternative})],
+			}));
+		}
+
+		return new Repeat({cmd: "repeat", args});
+	}
+
+
+	get type (): string {
+		return this.args[0];
+	}
+
+
+	get times () {
+		return Number(this.args[1]);
+	}
+
+
+	get bodyBlock (): MusicBlock {
+		return this.args[2];
+	}
+
+
+	get alternativeBlocks (): MusicBlock[] {
+		return this.args[3] && this.args[3].args[0].body;
+	}
+
+
+	// this result length equal to times, if not null
+	get completeAlternativeBlocks (): MusicBlock[] {
+		if (!this.alternativeBlocks || !this.alternativeBlocks.length)
+			return null;
+
+		if (this.alternativeBlocks.length >= this.times)
+			return this.alternativeBlocks.slice(0, this.times);
+
+		const list = [];
+		for (let i = 0; i < this.times - this.alternativeBlocks.length; ++ i)
+			list.push(this.alternativeBlocks[0]);
+		list.push(...this.alternativeBlocks);
+
+		return list;
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		switch (this.type) {
+		case "volta": {
+			const layout = new measureLayout.VoltaMLayout();
+			layout.times = this.times;
+			layout.body = this.bodyBlock.measureLayout.seq;
+			layout.alternates = this.alternativeBlocks && this.alternativeBlocks.map(block => block.measureLayout.seq);
+
+			return layout;
+		}
+
+		case "tremolo":
+			return this.bodyBlock.measureLayout;
+
+		default:
+			console.warn("unsupported repeat type:", this.type);
+		}
+
+		return null;
+	}
+
+
+	// for tremolo
+	get sumDuration (): Duration {
+		if (this.bodyBlock instanceof MusicEvent)
+			return Duration.fromMagnitude(this.args[2].durationMagnitude * this.times);
+		else if (this.bodyBlock instanceof MusicBlock) {
+			const events = this.bodyBlock.body.filter(term => term instanceof MusicEvent);
+			const magnitude = events.reduce((m, event) => m + event.durationMagnitude, 0) * this.times;
+
+			return Duration.fromMagnitude(magnitude);
+		}
+
+		return null;
+	}
+
+
+	get singleTremolo (): boolean {
+		if (this.type === "tremolo") {
+			if (this.bodyBlock instanceof MusicEvent)
+				return true;
+
+			if (this.bodyBlock instanceof MusicBlock) {
+				const events = this.bodyBlock.body.filter(term => term instanceof MusicEvent);
+				return events.length === 1;
+			}
+		}
+
+		return false;
+	}
+
+
+	// \repeat {body} \alternative {{alter1} {alter2}}		=> body alter1 body alter2
+	getUnfoldTerms (): BaseTerm[] {
+		const completeAlternativeBlocks = this.completeAlternativeBlocks;
+
+		const list = [];
+		for (let i = 0; i < this.times; ++i) {
+			list.push(...this.bodyBlock.clone().body);
+
+			if (completeAlternativeBlocks)
+				list.push(...completeAlternativeBlocks[i].clone().body);
+		}
+
+		return list;
+	}
+
+
+	// \repeat {body} \alternative {{alter1} {alter2}}		=> body alter1 alter2
+	getPlainTerms (): BaseTerm[] {
+		const list = [...this.bodyBlock.clone().body];
+
+		const alternativeBlocks = this.alternativeBlocks;
+		if (alternativeBlocks)
+			alternativeBlocks.forEach(block => list.push(...block.clone().body));
+
+		return list;
+	}
+
+
+	// \repeat {body} \alternative {{alter1} {alter2}}		=> body alter2
+	getTailPassTerms (): BaseTerm[] {
+		const list = [...this.bodyBlock.clone().body];
+
+		const alternativeBlocks = this.alternativeBlocks;
+		if (alternativeBlocks)
+			list.push(...alternativeBlocks[alternativeBlocks.length - 1].clone().body);
+
+		return list;
+	}
+};
+
+
+export class Relative extends Command {
+	static makeBlock (block: MusicBlock, {anchor}: {anchor?: ChordElement} = {}): Relative {
+		if (!anchor) {
+			const chord = block.findFirst(Chord) as Chord;
+			anchor = chord && chord.anchorPitch;
+		}
+
+		return new Relative({cmd: "relative", args: [anchor, block].filter(term => term)});
+	}
+
+
+	get anchor (): ChordElement {
+		if (this.args[0] instanceof ChordElement)
+			return this.args[0];
+
+		return null;
+	}
+
+
+	get music (): BaseTerm {
+		return this.args[this.args.length - 1];
+	}
+
+
+	get headChord (): Chord {
+		return this.findFirst(Chord) as Chord;
+	}
+
+
+	get tailPitch (): ChordElement {
+		const tail = this.findLast(Chord) as Chord;
+
+		return tail && tail.absolutePitch;
+	}
+
+
+	// with side effect
+	shiftBody (newAnchor?: ChordElement): BaseTerm[] {
+		const headChord = this.headChord;
+		if (newAnchor && headChord) {
+			headChord.shiftAnchor(newAnchor);
+			headChord._anchorPitch = null;
+			//console.log("shiftAnchor.post:", headChord.join(), headChord);
+		}
+
+		const music = this.music;
+		if (music instanceof MusicBlock) {
+			//music.clearPitchCache();
+			return music.body;
+		}
+
+		return [music];
+	}
+}
+
+
+export class ParallelMusic extends Command {
+	get varNames (): string[] {
+		return ((this.args[0].exp as SchemePointer).value as SchemeFunction).asList as string[];
+	}
+
+
+	get body (): MusicBlock {
+		return this.args[1];
+	}
+
+
+	get voices (): MusicVoice[] {
+		const voiceNames = this.varNames;
+		const chunks = this.body.musicChunks;
+		const measureCount = Math.ceil(chunks.length / voiceNames.length);
+
+		return voiceNames.map((name, index) => ({
+			name: name.toString(),
+			body: Array(measureCount).fill(null).map((_, m) => chunks[m * voiceNames.length + index]).filter(Boolean),
+		}));
+	}
+};
+
+
+export class TimeSignature extends Command {
+	get value (): FractionNumber {
+		return FractionNumber.fromExpression(this.args[0]);
+	}
+};
+
+
+export class Partial extends Command {
+	get duration (): Duration {
+		return this.args[0];
+	}
+};
+
+
+export class Times extends Command {
+	get factor (): FractionNumber {
+		return FractionNumber.fromExpression(this.args[0]);
+	}
+
+
+	get music (): BaseTerm {
+		return this.args[this.args.length - 1];
+	}
+};
+
+
+export class Tuplet extends Command {
+	get divider (): FractionNumber {
+		return FractionNumber.fromExpression(this.args[0]);
+	}
+
+
+	get music (): BaseTerm {
+		return this.args[this.args.length - 1];
+	}
+};
+
+
+export class Grace extends Command {
+	get music (): BaseTerm {
+		return this.args[this.args.length - 1];
+	}
+};
+
+
+export class AfterGrace extends Command {
+	get body (): BaseTerm {
+		return this.args[0];
+	}
+
+	get grace (): BaseTerm {
+		return this.args[1];
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		return measureLayout.BlockMLayout.fromSeq([
+			this.body.measureLayout,
+			this.grace.measureLayout,
+		]);
+	}
+};
+
+
+export class Clef extends Command {
+	get clefName (): string {
+		return this.args[0].toString();
+	}
+};
+
+
+export class KeySignature extends Command {
+	get keyPitch (): ChordElement {
+		return new ChordElement({pitch: this.args[0], options: {proto: "_PLAIN"}});
+	}
+
+
+	get key (): number {
+		const keyPitch = this.keyPitch;
+		const minor = this.args[1] === "\\minor";
+		const phonetOrder = idioms.FIFTH_PHONETS.indexOf(keyPitch.phonet);
+
+		return phonetOrder + (minor ? -4 : -1) + keyPitch.alterValue * 7;
+	}
+};
+
+
+export class OctaveShift extends Command {
+	get value (): number {
+		return this.args[0].exp;
+	}
+};
+
+
+export class Include extends Command {
+	static create (filename: string): Include {
+		return new Include({cmd: "include", args: [LiteralString.fromString(filename)]});
+	}
+
+
+	get filename (): string {
+		return this.args[0].toString();
+	}
+};
+
+
+export class Version extends Command {
+	static get default (): Version {
+		return new Version({cmd: "version", args: [LiteralString.fromString(LILYPOND_VERSION)]});
+	}
+
+
+	get version (): string {
+		return this.args[0].toString();
+	}
+};
+
+
+export class Language extends Command {
+	static make (language: string): Language {
+		return new Language({cmd: "language", args: [LiteralString.fromString(language)]});
+	}
+
+
+	get language (): string {
+		return this.args[0].toString();
+	}
+};
+
+
+export class LyricMode extends Command {
+	get block (): MusicBlock {
+		return this.args[0];
+	}
+};
+
+
+export class ChordMode extends Command {
+	get block (): MusicBlock {
+		return this.args[0];
+	}
+};
+
+
+export class Transposition extends Command {
+	get transposition (): number {
+		return this.args[0].pitchValue - 60;
+	}
+};
+
+
+export class StemDirection extends Command {
+	get direction (): string {
+		return this.cmd.substr(4);
+	}
+};
+
+
+export class Change extends Command {
+	get key (): string {
+		return this.args[0].toString();
+	}
+
+
+	get value (): string {
+		return this.args[1].toString();
+	}
+};
+
+
+export class Block extends BaseTerm {
+	block: string;
+	head: (string|string[]);
+	body: BaseTerm[];
+
+
+	constructor (data) {
+		super(data);
+
+		this.body = this.body.map(parseRawEnforce);
+	}
+
+
+	serialize () {
+		const heads = Array.isArray(this.head) ? this.head : (this.head ? [this.head] : []);
+
+		return [
+			...heads,
+			"{\n",
+			...cc(this.body.map(section => [...BaseTerm.optionalSerialize(section), "\n"])),
+			"}\n",
+		];
+	}
+
+
+	get entries () {
+		return this.body;
+	}
+
+
+	get isMIDIDedicated () {
+		const subBlocks = this.body.filter(term => term instanceof Block) as Block[];
+
+		return subBlocks.some(term => term.head === "\\midi")
+			&& !subBlocks.some(term => term.head === "\\layout");
+	}
+
+
+	get assignmentDict (): {[key: string]: string} {
+		const assignments = this.body.filter(term => term instanceof Assignment) as Assignment[];
+
+		return assignments.reduce((dict, assignment) => ((dict[assignment.key.toString()] = assignment.value.toString()), dict), {});
+	}
+};
+
+
+export class InlineBlock extends Block {
+	serialize () {
+		return [
+			"{",
+			...cc(this.body.map(BaseTerm.optionalSerialize)),
+			"}",
+		];
+	}
+};
+
+
+export class MusicBlock extends BaseTerm {
+	body: BaseTerm[];
+
+
+	static fromTerms (terms: BaseTerm[]): MusicBlock {
+		const block = new MusicBlock({body: [...terms]});
+		block.clarifyHead();
+
+		return block;
+	}
+
+
+	constructor (data) {
+		super(data);
+
+		this.body = this.body.map(parseRawEnforce);
+	}
+
+
+	serialize () {
+		return [
+			"{\n",
+			...cc(this.body.map(BaseTerm.optionalSerialize)),
+			"\n",
+			"}\n",
+		];
+	}
+
+
+	clone (): this {
+		if (this._parent) {
+			const parent = this._parent.clone();
+			const block = parent.findFirst(MusicBlock);
+			console.assert(block && block._parent === parent, "invalid block-parent relation", parent, block);
+
+			return block as this;
+		}
+
+		return BaseTerm.prototype.clone.call(this) as this;
+	}
+
+
+	get entries () {
+		return this.body;
+	}
+
+
+	get isMusic (): boolean {
+		return true;
+	}
+
+
+	get musicChunks (): MusicChunk[] {
+		const chunks = [];
+		let currentChunk = new MusicChunk(this);
+
+		const dumpChunk = () => {
+			if (currentChunk.size)
+				chunks.push(currentChunk);
+
+			currentChunk = new MusicChunk(this);
+		};
+
+		for (const term of this.entries) {
+			if (term instanceof Repeat) {
+				dumpChunk();
+				chunks.push(...term.musicChunks);
+			}
+			else if (term instanceof Divide)
+				dumpChunk();
+			else
+				currentChunk.push(term);
+		}
+
+		dumpChunk();
+
+		return chunks;
+	}
+
+
+	// [deprecated]
+	// for parallelMusic only
+	get voiceNames () {
+		const header = this._parent as Command;
+		if (header && header.cmd === "parallelMusic") {
+			if (header.args[0] instanceof Scheme && header.args[0].exp instanceof SchemePointer && header.args[0].exp.value instanceof SchemeFunction) {
+				const voices = header.args[0].exp.value.asList;
+				return voices;
+			}
+		}
+
+		return null;
+	}
+
+
+	// [deprecated]
+	get voices (): MusicVoice[] {
+		const voiceNames = this.voiceNames;
+		if (!voiceNames)
+			return [{body: this.musicChunks}];
+
+		const chunks = this.musicChunks;
+		const measureCount = Math.ceil(chunks.length / voiceNames.length);
+
+		return voiceNames.map((name, index) => ({
+			name: name.toString(),
+			body: Array(measureCount).fill(null).map((_, m) => chunks[m * voiceNames.length + index]).filter(chunk => chunk),
+		}));
+	}
+
+
+	get durationMagnitude (): number {
+		return this.body.reduce((magnitude, term) => magnitude + term.durationMagnitude, 0);
+	}
+
+
+	get isRelative (): boolean {
+		return this._parent instanceof Relative;
+	}
+
+
+	get anchorPitch (): ChordElement {
+		if (this.isRelative) 
+			return (this._parent as Relative).anchor;
+
+		return null;
+	}
+
+
+	get measures (): number[] {
+		// make a continouse indices list
+		const subterms = this.findAll(term => term.isMusic);
+		const subIndices = [].concat(...subterms.map(term => term.measures)).filter(index => Number.isInteger(index));
+		if (!subIndices.length)
+			return [];
+
+		const min = Math.min(...subIndices);
+		const max = Math.max(...subIndices);
+
+		return Array(max + 1 - min).fill(null).map((_, i) => i + min);
+	}
+
+
+	get notes (): Chord[] {
+		const notes = this.body.filter(term => term instanceof Chord && !term.isRest) as Chord[];
+		this.forEachTopTerm(MusicBlock, block => notes.push(...block.notes));
+
+		return notes;
+	}
+
+
+	get sonicNotes (): Chord[] {
+		return this.notes.filter(note => !note.completeTied);
+	}
+
+
+	get noteTicks (): number[] {
+		const ticks = this.sonicNotes.map(note => note._tick);
+		return Array.from(new Set(ticks)).sort((t1, t2) => t1 - t2);
+	}
+
+
+	get measureTicks (): [number, number][] {
+		const tickTable: {[key: string]: number} = {};
+
+		this.body.forEach(term => {
+			if (Number.isFinite(term._measure) && Number.isFinite(term._tick)) {
+				if (!Number.isFinite(tickTable[term._measure]))
+					tickTable[term._measure] = term._tick;
+			}
+		});
+
+		return Object.entries(tickTable).map(([measure, tick]) => [Number(measure), tick]);
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		const seq = this.body.filter(term => term.isMusic).map(term => term.measureLayout).filter(Boolean);
+
+		if (this._functional === "lotusRepeatABA") {
+			const [main, ...rest] = seq;
+
+			const layout = new measureLayout.ABAMLayout();
+			layout.main = main;
+			layout.rest = measureLayout.BlockMLayout.trimSeq(rest);
+
+			return layout;
+		}
+
+		return measureLayout.BlockMLayout.fromSeq(seq);
+	}
+
+
+	get measureChunkMap (): MusicChunkMap {
+		const map = new Map<number, MusicChunk>();
+		this.body.forEach(term => {
+			if (Number.isInteger(term._measure) && !(term instanceof Divide)) {
+				if (!map.get(term._measure))
+					map.set(term._measure, new MusicChunk(this));
+
+				const chunk = map.get(term._measure);
+				chunk.terms.push(term);
+			}
+		});
+
+		return map;
+	}
+
+
+	clearPitchCache () {
+		this.forEachTerm(ChordElement, pitch => {
+			pitch._absolutePitch = null;
+			//pitch._previous = null;
+		});
+	}
+
+
+	updateChordAnchors () {
+		const chord = this.findFirst(Chord) as Chord;
+		if (chord)
+			chord._anchorPitch = chord._anchorPitch || this.anchorPitch;
+
+		this.clearPitchCache();
+	}
+
+
+	// deprecated
+	updateChordChains () {
+		let previous: MusicEvent = null;
+
+		this.updateChordAnchors();
+
+		this.forEachTerm(MusicBlock, block => block.updateChordAnchors());
+
+		this.forEachTerm(MusicEvent, event => {
+			event._previous = previous;
+
+			previous = event;
+		});
+	}
+
+
+	// with side effect
+	spreadRepeatBlocks ({ignoreRepeat = true, keepTailPass = false} = {}): this {
+		this.forEachTerm(MusicBlock, block => block.spreadRepeatBlocks());
+
+		this.body = cc(this.body.map(term => {
+			if (term instanceof Repeat) {
+				if (!ignoreRepeat)
+					return term.getUnfoldTerms();
+				else if (keepTailPass)
+					return term.getTailPassTerms();
+				else
+					return term.getPlainTerms();
+			}
+			else
+				return [term];
+		}));
+
+		return this;
+	}
+
+
+	/*// with side effect
+	spreadRelativeBlocks (): this {
+		this.forEachTerm(MusicBlock, block => block.spreadRelativeBlocks());
+
+		let anchorPitch = null;
+
+		this.body = cc(this.body.map(term => {
+			if (term instanceof Relative) {
+				const list = term.shiftBody(anchorPitch);
+
+				anchorPitch = term.tailPitch || anchorPitch;
+
+				return list;
+			}
+			else
+				return [term];
+		}));
+
+		return this;
+	}*/
+
+
+	// with side effect
+	unfoldDurationMultipliers (): this {
+		let timeDenominator = 4;
+
+		const unfoldMultipliers = (term): BaseTerm[] => {
+			if (term instanceof TimeSignature)
+				timeDenominator = term.value.denominator;
+
+			if (!(term instanceof MusicEvent) || !term.duration || !term.duration.multipliers || !term.duration.multipliers.length)
+				return [term];
+
+			const factor = term.duration.multipliers.reduce((factor, multiplier) => factor * Number(multiplier), 1);
+			if (!Number.isInteger(factor) || factor <= 0)
+				return [term];
+
+			const denominator = Math.max(term.duration.denominator, timeDenominator);
+
+			const event = term.clone() as MusicEvent;
+			event.duration.multipliers = [];
+
+			// break duration into multiple rest events
+			const restCount = (event.duration.magnitude / WHOLE_DURATION_MAGNITUDE) * (factor - 1) * denominator;
+			if (!Number.isInteger(restCount))
+				console.warn("Rest count is not integear:", restCount, denominator, event.duration.magnitude, factor);
+
+			const rests = Array(Math.floor(restCount)).fill(null).map(() => 
+				new Rest({name: "s", duration: new Duration({number: denominator, dots: 0})}));
+
+			return [event, ...rests];
+		};
+
+		this.body = cc(this.body.map(unfoldMultipliers));
+
+		return this;
+	}
+
+
+	/*// pure
+	flatten ({spreadRepeats = false} = {}): Relative {
+		this.updateChordChains();
+
+		const chord = this.findFirst(Chord) as Chord;
+		const anchor = this.anchorPitch || (chord && chord.anchorPitch);
+
+		const block = this.clone();
+		if (spreadRepeats)
+			block.spreadRepeatBlocks();
+		block.spreadRelativeBlocks();
+		block.unfoldDurationMultipliers();
+
+		return Relative.makeBlock(block, {anchor: anchor && anchor.clone()});
+	}*/
+
+
+	// with side effect
+	expandVariables (dict: BaseTerm): this {
+		this.body = this.body.map(term => {
+			if (term instanceof Variable) {
+				const value = term.queryValue(dict);
+				const clonedValue = value instanceof BaseTerm ? value.clone() : value;
+
+				if (clonedValue instanceof BaseTerm) {
+					clonedValue.forEachTerm(MusicBlock, block => block.expandVariables(dict));
+
+					if (clonedValue instanceof MusicBlock)
+						clonedValue.expandVariables(dict);
+				}
+
+				return clonedValue;
+			}
+
+			return term;
+		});
+
+		return this;
+	}
+
+
+	// with side effects
+	redivide ({recursive = true, measureHeads = null}: {recursive?: boolean, measureHeads?: number[]} = {}) {
+		if (recursive) {
+			this.forEachTerm(MusicBlock, block => {
+				if (!block._parent || block._parent.cmd !== "alternative")
+					block.redivide({recursive, measureHeads});
+			});
+		}
+
+		// split rests
+		if (measureHeads) {
+			this.body = [].concat(...this.body.map(term => {
+				if (!(term instanceof Rest) || term.name !== "s" || !Number.isInteger(term._measure))
+					return [term];
+
+				const nextHead = measureHeads[term._measure];
+				const endTick = term._tick + term.durationMagnitude;
+				if (nextHead > 0 && endTick > nextHead) {
+					const post_events = term.post_events;
+
+					let startTick = term._tick;
+					const rests = [];
+					let nextMeasure;
+					for (nextMeasure = term._measure; nextMeasure < measureHeads.length && endTick > measureHeads[nextMeasure]; ++nextMeasure) {
+						const duration = Duration.fromMagnitude(measureHeads[nextMeasure] - startTick);
+						if (!duration) {
+							console.warn("invalid middle rest duration, splitting gave up:", measureHeads[nextMeasure] - startTick, term);
+							return [term];
+						}
+	
+						const rest = new Rest({name: "s", duration, post_events: []});
+						rest._measure = nextMeasure;
+						rest._lastMeasure = nextMeasure;
+						rests.push(rest);
+
+						console.assert(!!rest.duration, "middle splitted rest duration invalid:", measureHeads[nextMeasure] - startTick);
+
+						startTick = measureHeads[nextMeasure];
+					}
+
+					const duration = Duration.fromMagnitude(endTick - startTick);
+					if (!duration) {
+						console.warn("invalid tail rest duration, splitting gave up:", endTick - startTick, term);
+						return [term];
+					}
+
+					const rest = new Rest({name: "s", duration, post_events: post_events && [...post_events]});
+					rest._measure = nextMeasure;
+					rest._lastMeasure = nextMeasure;
+					rests.push(rest);
+
+					console.assert(rests.reduce((sum, rest) => sum + rest.durationMagnitude, 0) === term.durationMagnitude, "duration splitting error:", rests, term);
+					//if (rests.reduce((sum, rest) => sum + rest.durationMagnitude, 0) !== term.durationMagnitude)
+					//	debugger;
+
+					return rests;
+				}
+
+				return [term];
+			}));
+		}
+
+		const isPostTerm = term => !term
+			|| term instanceof PostEvent
+			|| (term as Primitive).exp === "~"
+			|| ["bar", "arpeggio", "glissando", "sustainOff", "sustainOn"].includes((term as Command).cmd)
+			;
+
+		const list = this.body.filter(term => !(term instanceof Divide));
+		let measure = null;
+		for (const term of list) {
+			if (Number.isInteger(measure) && isPostTerm(term))
+				term._measure = measure;
+			else
+				measure = term._measure;
+		}
+
+		const body: BaseTerm[] = [];
+		const measures = new Set();
+
+		list.reverse().forEach(term => {
+			if (term instanceof BaseTerm) {
+				const newMeasures = term.measures.filter(m => !measures.has(m));
+				if (newMeasures.length) {
+					const comment = " " + newMeasures[0] + (newMeasures.length > 1 ? "-" + Math.max(...newMeasures) : "");
+
+					if (body.length)
+						body.push(new Divide({_tailComment: Comment.createSingle(comment)}));
+
+					newMeasures.forEach(m => measures.add(m));
+				}
+			}
+
+			body.push(term);
+		});
+
+		this.body = body.reverse();
+	}
+
+
+	clarifyHead () {
+		const terms = this.body;
+
+		const head = terms.find(term => term.isMusic);
+		if (head instanceof MusicEvent) {
+			// clarify the first music event content
+			const firstEventIndex = terms.indexOf(head);
+			if (firstEventIndex >= 0) {
+				const firstEvent = terms[firstEventIndex] as MusicEvent;
+				//console.log("firstEvent:", firstEvent);
+				if (firstEvent._previous) {
+					const clarified = firstEvent.clarified;
+	
+					terms.splice(firstEventIndex, 1, clarified);
+					//console.log("terms:", firstEventIndex, terms, clarified);
+				}
+			}
+		}
+		else if (head) {
+			const block = head.findFirst(MusicBlock) as MusicBlock;
+			if (block)
+				block.clarifyHead();
+			else
+				console.warn("[MusicBlock.clarifyHead] unexpected music head:", head);
+		}
+	}
+
+
+	absoluteToRelative (): Relative {
+		const anchor = this.findFirst(Chord) as Chord;
+		if (!anchor)
+			return null;
+
+		const anchorPitch = anchor.absolutePitch;
+		let pitch = anchorPitch;
+
+		const newBody = this.clone();
+		newBody.forEachTerm(Chord, chord => {
+			const newPitch = chord.absolutePitch;
+			chord.makeRelativeTo(pitch);
+
+			pitch = newPitch;
+		});
+
+		return Relative.makeBlock(newBody, {anchor: anchorPitch});
+	}
+};
+
+
+export class SimultaneousList extends BaseTerm {
+	list: BaseTerm[];
+
+
+	serialize () {
+		return [
+			"<<\n",
+			...cc(this.list.map(item => [...BaseTerm.optionalSerialize(item), "\n"])),
+			">>\n",
+		];
+	}
+
+
+	removeStaffGroup () {
+		for (let i = 0; i < this.list.length; ++i) {
+			const item: any = this.list[i];
+			if (item.head instanceof Command && item.head.args && item.head.args[0] === "StaffGroup")
+				this.list[i] = item.body;
+		}
+
+		this.list.forEach(item => {
+			if (item instanceof SimultaneousList)
+				item.removeStaffGroup();
+		});
+	}
+
+
+	get isMusic (): boolean {
+		return true;
+	}
+
+
+	get entries () {
+		return this.list;
+	}
+
+
+	get durationMagnitude (): number {
+		return Math.max(...this.list.filter(term => term instanceof BaseTerm).map(term => term.durationMagnitude));
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		const track = this.list.find(term => term instanceof BaseTerm && term.measureLayout);
+		return track && track.measureLayout;
+	}
+};
+
+
+export class ContextedMusic extends BaseTerm {
+	head: Command;
+	body: BaseTerm;
+	lyrics?: BaseTerm;
+
+
+	serialize () {
+		return [
+			...BaseTerm.optionalSerialize(this.head),
+			...BaseTerm.optionalSerialize(this.body),
+			...BaseTerm.optionalSerialize(this.lyrics),
+		];
+	}
+
+
+	get isMusic (): boolean {
+		return true;
+	}
+
+
+	get entries () {
+		return [this.head, this.body];
+	}
+
+
+	get type (): string {
+		return this.head.args[0];
+	}
+
+
+	get durationMagnitude (): number {
+		return this.body.durationMagnitude;
+	}
+
+
+	get withClause (): Command {
+		if (this.head.args[2] && this.head.args[2] instanceof Command && this.head.args[2].cmd === "with")
+			return this.head.args[2];
+	}
+
+
+	get contextDict (): {[key: string]: string} {
+		const withEntries = this.withClause ? Object.entries((this.withClause.args[0] as Block).assignmentDict) : [];
+		const entries = withEntries.map(([key, value]) => [`${this.type}.${key}`, value]);
+
+		const pair = this.head.getAssignmentPair();
+		if (pair)
+			entries.push([pair.key.toString(), pair.value.toString()]);
+
+		return entries.reduce((dict, [key, value]) => ((dict[key] = value), dict), {});
+	}
+
+
+	get list (): BaseTerm[] {
+		if (this.body instanceof SimultaneousList)
+			return this.body.list;
+
+		return null;
+	}
+
+
+	set list (value: BaseTerm[]) {
+		if (this.body instanceof SimultaneousList)
+			this.body.list = value;
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		return this.body.measureLayout;
+	}
+};
+
+
+export class Divide extends BaseTerm {
+	serialize () {
+		return ["|", "\n"];
+	}
+}
+
+
+export class Scheme extends BaseTerm {
+	exp: (boolean|BaseTerm);
+
+
+	serialize () {
+		if (BaseTerm.isTerm(this.exp))
+			return ["#", "\b", ...(this.exp as BaseTerm).serialize()];
+		else if (typeof this.exp === "boolean")
+			return ["#", "\b", this.exp ? "#t" : "#f"];
+		// TODO: enhance grammar to parse empty scheme list
+		//else if (this.exp === null)
+		//	return ["#", "\b", "'()"];
+		else
+			return ["#", "\b", this.exp];
+	}
+
+
+	query (key: string): any {
+		if (this.exp instanceof SchemeFunction)
+			return this.exp.query(key);
+	}
+
+
+	get entries () {
+		if (this.exp instanceof BaseTerm)
+			return [this.exp];
+
+		return [];
+	}
+};
+
+
+export class SchemeFunction extends BaseTerm {
+	func: (string | BaseTerm);
+	args: (boolean | string | BaseTerm)[];
+
+
+	serialize () {
+		return [
+			"(", "\b",
+			...BaseTerm.optionalSerialize(this.func),
+			...cc(this.args.map(BaseTerm.serializeScheme)),
+			"\b", ")",
+		];
+	}
+
+
+	query (key: string): any {
+		if (key === this.func) {
+			const term = this;
+
+			return {
+				get value () {
+					return term.args.length === 1 ? term.args[0] : term.args;
+				},
+
+				set value (value) {
+					if (term.args.length === 1)
+						term.args[0] = value as string|BaseTerm;
+					else
+						term.args = value as (string|BaseTerm)[];
+				},
+			};
+		}
+	}
+
+
+	get asList (): (boolean | string | BaseTerm)[] {
+		return [this.func, ...this.args];
+	}
+
+
+	get entries () {
+		return this.asList.filter(term => term instanceof BaseTerm) as BaseTerm[];
+	}
+};
+
+
+export class SchemePair extends BaseTerm {
+	left: any;
+	right: any;
+
+
+	serialize () {
+		return [
+			"(", "\b",
+			...BaseTerm.optionalSerialize(this.left), ".", ...BaseTerm.optionalSerialize(this.right),
+			"\b", ")",
+		];
+	}
+};
+
+
+export class SchemePointer extends BaseTerm {
+	value: any;
+
+
+	serialize () {
+		const content = this.value === null ? ["()"] : BaseTerm.optionalSerialize(this.value);
+
+		return [
+			"'", "\b", ...content,
+		];
+	}
+
+
+	get entries () {
+		if (this.value instanceof BaseTerm)
+			return [this.value];
+
+		return [];
+	}
+};
+
+
+export class SchemeEmbed extends BaseTerm {
+	value: Root;
+
+
+	serialize () {
+		return [
+			"#{",
+			...BaseTerm.optionalSerialize(this.value),
+			"#}",
+		];
+	}
+};
+
+
+export class Assignment extends BaseTerm {
+	key: (string|any[]);
+	value: any;
+
+
+	constructor (data) {
+		super(data);
+
+		if (this.value instanceof BaseTerm)
+			this.value._parent = this;
+	}
+
+
+	serialize () {
+		const keys = (Array.isArray(this.key) ? this.key : [this.key]).map(BaseTerm.optionalSerialize);
+		const values = (Array.isArray(this.value) ? this.value : [this.value]).map(BaseTerm.optionalSerialize);
+
+		return [
+			...cc(keys),
+			"=",
+			...cc(values),
+		];
+	}
+
+
+	get entries () {
+		if (this.value instanceof BaseTerm)
+			return [this.value];
+
+		return null;
+	}
+
+
+	query (key) {
+		if (this.key === key) {
+			const term = this;
+
+			return {
+				get value () {
+					return term.value;
+				},
+
+				set value (value) {
+					term.value = value;
+				},
+			};
+		}
+	}
+};
+
+
+export class MusicEvent extends BaseTerm {
+	duration?: Duration;
+	post_events?: (string | PostEvent)[];
+
+	declare _previous?: MusicEvent;
+	//_anchorPitch?: ChordElement;
+	_lastMeasure?: number;
+
+
+	constructor (data: object) {
+		super(data);
+
+		if (this.post_events)
+			this.post_events = this.post_events.map(parseRaw);
+	}
+
+
+	getPreviousT (T) {
+		if (this._previous instanceof T)
+			return this._previous;
+
+		if (this._previous)
+			return this._previous.getPreviousT(T);
+	}
+
+
+	get durationValue (): Duration {
+		return this.duration || (this._previous ? this._previous.durationValue : Duration.default);
+	}
+
+
+	get durationMagnitude (): number {
+		return this.durationValue.magnitude;
+	}
+
+
+	get division (): number {
+		return this.durationValue.division;
+	}
+
+
+	get withMultiplier () {
+		return this.duration && this.duration.withMultiplier;
+	}
+
+
+	get isMusic (): boolean {
+		return true;
+	}
+
+
+	get isTying (): boolean {
+		return this.post_events && this.post_events.some(event => event instanceof PostEvent && event.isTying);
+	}
+
+
+	get isStaccato (): boolean {
+		return this.post_events && this.post_events.some(event => event instanceof PostEvent && event.isStaccato);
+	}
+
+
+	// to be implement in derived classes
+	get isRest (): boolean {
+		return null;
+	}
+
+
+	get beamOn (): boolean {
+		return this.post_events && this.post_events.includes("[");
+	}
+
+
+	get beamOff (): boolean {
+		return this.post_events && this.post_events.includes("]");
+	}
+
+
+	get measures (): number[] {
+		if (!Number.isFinite(this._measure) || !Number.isFinite(this._lastMeasure))
+			return [];
+
+		return Array(this._lastMeasure + 1 - this._measure).fill(null).map((_, i) => this._measure + i);
+	}
+
+
+	get measureLayout (): measureLayout.MeasureLayout {
+		if (this.measures.length > 1)
+			return measureLayout.BlockMLayout.fromSeq(this.measures.map(measure => measureLayout.SingleMLayout.from(measure)));
+
+		if (this.measures.length === 1)
+			return measureLayout.SingleMLayout.from(this._measure);
+
+		return null;
+	}
+
+
+	get implicitType (): ImplicitType {
+		if (this.post_events) {
+			for (const event of this.post_events) {
+				if (event instanceof PostEvent && event.arg instanceof Command) {
+					switch (event.arg.cmd) {
+					case "startTrillSpan":
+					case "trill":
+						return ImplicitType.Trill;
+
+					case "turn":
+						return ImplicitType.Turn;
+
+					case "mordent":
+						return ImplicitType.Mordent;
+
+					case "prall":
+						return ImplicitType.Prall;
+
+					// Arpeggio is not implemented in 'articulate.ly' yet
+					case "arpeggio":
+						return ImplicitType.Arpeggio;
+					}
+				}
+			}
+		}
+
+		return ImplicitType.None;
+	}
+
+
+	get clarified (): MusicEvent {
+		const clarified = this instanceof Chord ? this.clarifiedChord : this.clone();
+		clarified.duration = this.durationValue && this.durationValue.clone();
+
+		return clarified;
+	}
+};
+
+
+export class Chord extends MusicEvent {
+	pitches: (ChordElement | Command)[];
+	options: {
+		exclamations?: string[],
+		questions?: string[],
+		rest?: string,
+		withAngle?: boolean,
+	};
+
+
+	constructor (data) {
+		super(data);
+
+		this.connectPitches();
+	}
+
+
+	connectPitches () {
+		if (this.basePitch)
+			this.basePitch._parent = this;
+		for (let i = 1; i < this.pitchElements.length; ++i)
+			this.pitchElements[i]._previous = this.pitchElements[i - 1];
+	}
+
+
+	get single (): boolean {
+		return this.pitches.length === 1;
+	}
+
+
+	get entries () {
+		const list: any[] = [...this.pitches];
+		if (Array.isArray(this.post_events))
+			list.push(...this.post_events);
+
+		return list;
+	}
+
+
+	serialize () {
+		const innerPitches = this.pitches.map(BaseTerm.optionalSerialize);
+		const pitches = (this.single && !this.options.withAngle) ? cc(innerPitches) : [
+			"<", "\b", ...cc(innerPitches), "\b", ">",
+		];
+
+		const {exclamations, questions, rest} = this.options;
+		const postfix = cc([...(exclamations || []), ...(questions || []), ...BaseTerm.optionalSerialize(this.duration), rest]
+			.filter(item => item)
+			.map(item => ["\b", item]),
+		).concat(...(this.post_events || []).map(BaseTerm.optionalSerialize));
+
+		return [
+			new OpenLocator(this),
+			...pitches,
+			...postfix,
+			new CloseLocator(this),
+		];
+	}
+
+
+	get pitchElements (): ChordElement[] {
+		return this.pitches.filter(pitch => pitch instanceof ChordElement) as ChordElement[];
+	}
+
+
+	get pitchNames (): string[] {
+		return this.pitchElements.map((elem: ChordElement) => elem.pitch.replace(/'|,/g, ""));
+	}
+
+
+	get basePitch (): ChordElement {
+		return this.pitchElements[0];
+	}
+
+
+	get absolutePitch (): ChordElement {
+		console.assert(!!this.basePitch, "absolutePitch on non pitch:", this.join());
+		return this.basePitch.absolutePitch;
+	}
+
+
+	get anchorPitch (): ChordElement {
+		if (this._anchorPitch)
+			return this._anchorPitch;
+
+		const previous = this.getPreviousT(Chord);
+		if (previous)
+			return previous.absolutePitch;
+
+		return this.basePitch;
+	}
+
+
+	get isRest (): boolean {
+		return !!this.options.rest;
+	}
+
+
+	get completeTied (): boolean {
+		return this.pitchElements.filter(pitch => !pitch._tied).length === 0;
+	}
+
+
+	get pitchesValue (): (ChordElement | Command)[] {
+		if (this._previous instanceof Chord && this.basePitch.pitch === "q") {
+			const pitches = this._previous.pitchesValue.map(pitch => {
+				const newPitch = pitch.clone();
+				if (newPitch instanceof ChordElement) {
+					newPitch._location = this.basePitch._location;
+					newPitch._tied = this.basePitch._tied;
+					newPitch._parent = (pitch as ChordElement)._parent && this;
+					newPitch._previous = (pitch as ChordElement)._previous;
+				}
+
+				return newPitch;
+			});
+			const base = pitches.find(pitch => pitch instanceof ChordElement) as ChordElement;
+			if (base)
+				base.pitch = base.pitch.replace(/[,']/g, "");
+
+			return pitches;
+		}
+
+		return this.pitches;
+	}
+
+
+	get clarifiedChord (): MusicEvent {
+		const clarified = this.clone();
+		clarified.pitches = this.pitchesValue.filter(pitch => !(pitch as ChordElement)._tied).map(pitch => pitch.clone());
+		clarified.connectPitches();
+
+		// replace by rest if all pitches tied
+		if (!clarified.pitches.length)
+			return new Rest({name: "r", duration: this.duration});
+
+		return clarified;
+	}
+
+
+	shiftAnchor (newAnchor: ChordElement) {
+		//console.warn("shiftAnchor:", this.join(), newAnchor.join(), this.absolutePitch.pitchValue, newAnchor.pitchValue, this.anchorPitch.pitchValue);
+		const _location = this.basePitch._location;
+		const shift = idioms.phonetDifferToShift(this.basePitch.phonetStep - newAnchor.phonetStep);
+		const relativeOctave = this.basePitch.absoluteOctave(this.anchorPitch) - newAnchor.octave - shift;
+		//console.log("_location:", _location);
+
+		this.pitches[0] = ChordElement.from({
+			phonet: this.basePitch.phonet,
+			alters: this.basePitch.alters,
+			octave: relativeOctave,
+		});
+
+		this.pitches[0]._location = _location;
+		this.pitches[0]._parent = this;
+
+		this.connectPitches();
+
+		//console.log("shiftAnchor.1:", this.join(), this.absolutePitch.pitchValue, {relativeOctave, shift, "newAnchor.octave": newAnchor.octave});
+	}
+
+
+	makeRelativeTo (from: ChordElement) {
+		const _location = this.basePitch._location;
+
+		const octave = this.basePitch.relativeOctave(from);
+		this.pitches[0] = ChordElement.from({
+			phonet: this.basePitch.phonet,
+			alters: this.basePitch.alters,
+			octave,
+		});
+
+		this.pitches[0]._location = _location;
+		this.pitches[0]._parent = this;
+	}
+};
+
+
+export class Rest extends MusicEvent {
+	name: string;
+
+
+	serialize () {
+		return [
+			new OpenLocator(this),
+			...compact([
+				this.name,
+				...BaseTerm.optionalSerialize(this.duration),
+			]),
+			...cc((this.post_events || []).map(BaseTerm.optionalSerialize)),
+			new CloseLocator(this),
+		];
+	}
+
+
+	get isSpacer () {
+		return this.name === "s";
+	}
+
+
+	get isRest (): boolean {
+		return true;
+	}
+};
+
+
+export class ChordElement extends BaseTerm {
+	pitch: string;
+	options: {
+		exclamations?: string[],
+		questions?: string[],
+		post_events?: PostEvent[],
+	};
+
+	declare _parent?: Chord;
+	declare _previous?: ChordElement;
+	_tied?: MusicEvent;
+	_transposition?: number;
+
+	// cache for property of absolutePitch
+	_absolutePitch?: ChordElement;
+
+
+	static from ({phonet, alters = "", octave, options = {}}): ChordElement {
+		const octaveString = octave ? Array(Math.abs(octave)).fill(octave > 0 ? "'" : ",").join("") : "";
+		const pitch = phonet + (alters || "") + octaveString;
+
+		return new ChordElement({pitch, options: {...options, proto: "_PLAIN"}});
+	}
+
+
+	static get default (): ChordElement {
+		return ChordElement.from({phonet: "c", octave: 0});
+	}
+
+
+	constructor (data: object) {
+		super(data);
+
+		if (this.options.post_events)
+			this.options.post_events = this.options.post_events.map(parseRaw);
+
+		if (!this.pitch)
+			console.log("null pitch:", this);
+	}
+
+
+	serialize () {
+		const {exclamations, questions, post_events} = this.options;
+		const postfix = [].concat(...[...(exclamations || []), ...(questions || [])]
+			.filter(item => item)
+			.map(item => ["\b", item]),
+		).concat(...(post_events || []).map(item => ["\b", ...BaseTerm.optionalSerialize(item)]));
+
+		return [
+			new OpenLocator(this),
+			this.pitch,
+			...postfix,
+			new CloseLocator(this),
+		];
+	}
+
+
+	get octave (): number {
+		const positive = (this.pitch.match(/'/g) || []).length;
+		const negative = (this.pitch.match(/,/g) || []).length;
+
+		return positive - negative;
+	}
+
+
+	get phonet (): string {
+		const ph = this.pitch.substr(0, 1);
+
+		return idioms.PHONETS_ALIAS[ph] || ph;
+	}
+
+
+	get phonetStep (): number {
+		return idioms.PHONETS.indexOf(this.phonet);
+	}
+
+
+	get alters (): string {
+		const captures = this.pitch.substr(1).match(/^\w+/);
+		return captures && captures[0];
+	}
+
+
+	get alteredPhonet (): string {
+		const captures = this.pitch.match(/^\w+/);
+		return captures && captures[0];
+	}
+
+
+	get anchorPitch (): ChordElement {
+		if (this._previous)
+			return this._previous.absolutePitch;
+
+		if (this._parent)
+			return this._parent.anchorPitch;
+
+		return ChordElement.from({phonet: this.phonet, octave: 0});
+	}
+
+
+	getAbsolutePitch (): ChordElement {
+		if (this.phonet === "q")
+			return this.anchorPitch;
+
+		if (this.anchorPitch === this)
+			return this;
+
+		const octave = this.absoluteOctave(this.anchorPitch);
+
+		return ChordElement.from({phonet: this.phonet, alters: this.alters, octave});
+	}
+
+
+	get absolutePitch (): ChordElement {
+		if (!this._absolutePitch)
+			this._absolutePitch = this.getAbsolutePitch();
+
+		return this._absolutePitch;
+	}
+
+
+	absoluteOctave (anchor: ChordElement): number {
+		if (this.phonet === "q")
+			return anchor.octave;
+
+		const phonetDiffer = this.phonetStep - anchor.phonetStep;
+		const shift = idioms.phonetDifferToShift(phonetDiffer);
+
+		return anchor.octave + shift + this.octave;
+	}
+
+
+	relativeOctave (from: ChordElement): number {
+		if (this.phonet === "q") {
+			if (this.anchorPitch)
+				return this.anchorPitch.relativeOctave(from);
+			else
+				return 0;
+		}
+
+		const phonetDiffer = this.phonetStep - from.phonetStep;
+		const shift = idioms.phonetDifferToShift(phonetDiffer);
+
+		return this.octave - shift - from.octave;
+	}
+
+
+	get alterValue (): number {
+		return idioms.ALTER_VALUES[this.alters] || 0;
+	}
+
+
+	get pitchValue (): number {
+		const phonetValue = idioms.PHONET_VALUES[this.phonet];
+		console.assert(Number.isInteger(phonetValue), "invalid phonet:", this.phonet);
+		console.assert(!this.alters || idioms.ALTER_VALUES[this.alters], "invalid alters:", this.alters);
+
+		return 48 + this.octave * 12 + phonetValue + this.alterValue;
+	}
+
+
+	get absolutePitchValue (): number {
+		return this.absolutePitch.pitchValue;
+	}
+
+
+	// middle C is zero
+	get notePosition (): number {
+		const phonet = idioms.PHONETS.indexOf(this.phonet);
+
+		return (this.octave - 1) * 7 + phonet;
+	}
+
+
+	get absoluteNotePosition (): number {
+		return this.absolutePitch.notePosition;
+	}
+
+
+	get tiedParent (): ChordElement {
+		if (!this._tied || !(this._tied instanceof Chord))
+			return null;
+
+		const pitch = this._tied.pitchElements.find(p => p.absolutePitchValue === this.absolutePitchValue);
+		if (!pitch)
+			return null;
+
+		if (pitch._tied)
+			return pitch.tiedParent;
+
+		return pitch;
+	}
+};
+
+
+export class Duration extends BaseTerm {
+	number: string;
+	dots: number;
+	multipliers?: string[];
+
+
+	static _default: Duration;
+	static get default (): Duration {
+		if (!Duration._default)
+			Duration._default = new Duration({number: 4, dots: 0});
+
+		return Duration._default;
+	}
+
+
+	static fromMagnitude (magnitude: number): Duration {
+		const MULTI = 1024;
+		const MULTI_DURATION_MAGNITUDE = WHOLE_DURATION_MAGNITUDE * MULTI;
+		const multiMag = magnitude * MULTI;
+		if (!Number.isInteger(multiMag)) {
+			console.warn("magnitude must be integer:", magnitude);
+			return null;
+		}
+
+		const di = gcd(multiMag, MULTI_DURATION_MAGNITUDE);
+		const denominator = MULTI_DURATION_MAGNITUDE / di;
+		const numerator = multiMag / di;
+		if (!Number.isInteger(Math.log2(denominator)))
+			return new Duration({number: 1, dots: 0, multipliers: [`${numerator}/${denominator}`]});
+
+		switch (numerator) {
+		case 1:
+			return new Duration({number: denominator, dots: 0});
+
+		case 3:
+			return new Duration({number: denominator / 2, dots: 1});
+
+		case 7:
+			return new Duration({number: denominator / 4, dots: 2});
+
+		default:
+			return new Duration({number: denominator, dots: 0, multipliers: [numerator.toString()]});
+		}
+	}
+
+
+	serialize () {
+		const dots = Array(this.dots).fill(".").join("");
+		const multipliers = this.multipliers && this.multipliers.map(multiplier => `*${multiplier}`).join("");
+
+		return compact([
+			this.number, dots, multipliers,
+		]);
+	}
+
+
+	get withMultiplier () {
+		return this.multipliers && this.multipliers.length > 0;
+	}
+
+
+	get denominator (): number {
+		switch (this.number) {
+		case "\\breve":
+			return 0.5;
+
+		case "\\longa":
+			return 0.25;
+		}
+
+		return Number(this.number);
+	}
+
+
+	get division (): number {
+		return Math.log2(this.denominator);
+	}
+
+
+	// how many smallest rhythm unit in a whole note
+	get subdivider (): number {
+		return this.denominator * (2 ** this.dots);
+	}
+
+
+	get magnitude (): number {
+		let value = WHOLE_DURATION_MAGNITUDE / this.denominator;
+
+		if (this.dots)
+			value *= 2 - 0.5 ** this.dots;
+
+		if (this.multipliers)
+			this.multipliers.forEach(multiplier => value *= eval(multiplier));
+
+		return value;
+	}
+};
+
+
+interface BriefChordBody {
+	pitch: string;
+	duration: Duration;
+	separator: string;
+	items: string[];
+};
+
+
+export class BriefChord extends BaseTerm {
+	body: BriefChordBody;
+	post_events: any[];
+
+
+	constructor (data: object) {
+		super(data);
+
+		if (this.body)
+			this.body.duration = parseRaw(this.body.duration);
+	}
+
+
+	serialize () {
+		const {pitch, duration, separator, items} = this.body;
+
+		return [
+			...compact(cc([pitch, duration, separator, ...(items || [])].map(BaseTerm.optionalSerialize))),
+			...cc((this.post_events || []).map(BaseTerm.optionalSerialize)),
+		];
+	}
+
+
+	get isMusic (): boolean {
+		return true;
+	}
+
+
+	get durationMagnitude (): number {
+		if (this.body.duration)
+			return this.body.duration.magnitude;
+
+		return 0;
+	}
+};
+
+
+export class NumberUnit extends BaseTerm {
+	number: number;
+	unit: string;
+
+
+	serialize () {
+		return [this.number, "\b", this.unit];
+	}
+
+
+	set ({number, unit}) {
+		this.number = Number(number.toFixed(2));
+
+		if (unit !== undefined)
+			this.unit = unit;
+	}
+}
+
+
+export class Tempo extends BaseTerm {
+	beatsPerMinute?: number;
+	unit?: Duration;
+	text?: string;
+
+
+	static fromNoteBpm (note: number, bpm: number): Tempo {
+		return new Tempo ({
+			unit: new Duration({number: note.toString(), dots: 0}),
+			beatsPerMinute: bpm,
+		});
+	}
+
+
+	serialize () {
+		const assignment = Number.isFinite(this.beatsPerMinute) ? [...BaseTerm.optionalSerialize(this.unit), "=", this.beatsPerMinute] : [];
+
+		return [
+			"\\tempo",
+			...BaseTerm.optionalSerialize(this.text),
+			...assignment,
+		];
+	}
+}
+
+
+const DIRECTION_CHAR = {
+	up: "^",
+	down: "_",
+	middle: "-",
+};
+
+
+export class PostEvent extends BaseTerm {
+	direction: string;
+	arg: string | BaseTerm;
+
+
+	serialize () {
+		const dir = DIRECTION_CHAR[this.direction];
+		const prefix = dir ? [dir, "\b"] : [];
+
+		return prefix.concat(BaseTerm.optionalSerialize(this.arg));
+	}
+
+
+	get entries () {
+		if (this.arg instanceof BaseTerm)
+			return [this.arg];
+
+		return null;
+	}
+
+
+	get isTying (): boolean {
+		return this.arg === "~";
+	}
+
+
+	get isStaccato (): boolean {
+		if (this.arg instanceof Command)
+			return ["staccato", "staccatissimo", "portato"].includes(this.arg.cmd);
+
+		if ([".", "!"].includes(this.arg as string))
+			return true;
+
+		return false;
+	}
+};
+
+
+export class Fingering extends BaseTerm {
+	value: number;
+
+
+	serialize () {
+		return [this.value];
+	}
+};
+
+
+export class Markup extends BaseTerm {
+	head: any[];
+	body: (string|BaseTerm);
+
+
+	serialize () {
+		return [
+			...cc(this.head.map(BaseTerm.optionalSerialize)),
+			...BaseTerm.optionalSerialize(this.body),
+		];
+	}
+};
+
+
+export class Lyric extends MusicEvent {
+	content: string | LiteralString;
+
+
+	serialize () {
+		return [
+			...BaseTerm.optionalSerialize(this.content),
+			...BaseTerm.optionalSerialize(this.duration),
+			...cc((this.post_events || []).map(BaseTerm.optionalSerialize)),
+		];
+	}
+};
+
+
+export class Comment extends BaseTerm {
+	text: string;
+	scoped: boolean;
+
+
+	serialize () {
+		return [
+			this.text,
+			"\n",
+		];
+	}
+
+
+	static createSingle (text): Comment {
+		return new Comment({text: "%" + text});
+	}
+
+
+	static createScoped (text): Comment {
+		console.assert(!/%\}/.test(text), "invalid scoped comment text:", text);
+
+		return new Comment({text: `%{${text}%}`, scoped: true});
+	}
+};
+
+
+export class Unexpect extends BaseTerm {
+	constructor (data) {
+		super(data);
+
+		console.warn("unexpected term", data);
+	}
+};
+
+
+export const termDictionary = {
+	Root,
+	LiteralString,
+	Command,
+	Variable,
+	MarkupCommand,
+	Repeat,
+	Relative,
+	ParallelMusic,
+	TimeSignature,
+	Partial,
+	Times,
+	Tuplet,
+	Grace,
+	AfterGrace,
+	Clef,
+	KeySignature,
+	OctaveShift,
+	Include,
+	Version,
+	Language,
+	LyricMode,
+	ChordMode,
+	Transposition,
+	StemDirection,
+	Change,
+	Block,
+	InlineBlock,
+	Scheme,
+	SchemeFunction,
+	SchemePair,
+	SchemePointer,
+	SchemeEmbed,
+	Assignment,
+	Duration,
+	ChordElement,
+	Chord,
+	Rest,
+	BriefChord,
+	NumberUnit,
+	MusicBlock,
+	SimultaneousList,
+	ContextedMusic,
+	Divide,
+	Tempo,
+	PostEvent,
+	Fingering,
+	Markup,
+	Lyric,
+	Primitive,
+	Comment,
+};
+
+
+const termProtoMap: Map<object, string> = Object.entries(termDictionary)
+	.reduce((map, [name, cls]: [string, {prototype: object}]) => (map.set(cls.prototype, name), map), new Map());
+
+
+const parseRawEnforce = data => {
+	switch (typeof data) {
+	case "string":
+	case "number":
+		return new Primitive({exp: data});
+
+	default:
+		return parseRaw(data);
+	}
+};
+
+
+export const parseRaw = data => {
+	if (data instanceof BaseTerm)
+		return data;
+
+	if (!data)
+		return data;
+
+	switch (typeof data) {
+	case "object":
+		if (Array.isArray(data))
+			return data.map(item => parseRaw(item));
+
+		const {proto, ...fields} = data;
+		if (proto) {
+			if (proto === "_PLAIN")
+				return fields;
+
+			const termClass = termDictionary[proto];
+			if (!termClass)
+				throw new Error(`Unexpected term class: ${data.proto}`);
+
+			return new termClass(fields);
+		}
+
+		return new Unexpect(data); 
+	}
+
+	return data;
+};