]*>([\s\S]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i],[PR.PR_DECLARATION,/^{{[#^>/]?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{&?\s*[\w.][^}]*}}/],[PR.PR_DECLARATION,/^{{{>?\s*[\w.][^}]*}}}/],[PR.PR_COMMENT,/^{{![^}]*}}/]]),["handlebars","hbs"]);PR.registerLangHandler(PR.createSimpleLexer([[PR.PR_PLAIN,/^[ \t\r\n\f]+/,null," \t\r\n\f"]],[[PR.PR_STRING,/^\"(?:[^\n\r\f\\\"]|\\(?:\r\n?|\n|\f)|\\[\s\S])*\"/,null],[PR.PR_STRING,/^\'(?:[^\n\r\f\\\']|\\(?:\r\n?|\n|\f)|\\[\s\S])*\'/,null],["lang-css-str",/^url\(([^\)\"\']*)\)/i],[PR.PR_KEYWORD,/^(?:url|rgb|\!important|@import|@page|@media|@charset|inherit)(?=[^\-\w]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|(?:\\[0-9a-f]+ ?))(?:[_a-z0-9\-]|\\(?:\\[0-9a-f]+ ?))*)\s*:/i],[PR.PR_COMMENT,/^\/\*[^*]*\*+(?:[^\/*][^*]*\*+)*\//],[PR.PR_COMMENT,/^(?:)/],[PR.PR_LITERAL,/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],[PR.PR_LITERAL,/^#(?:[0-9a-f]{3}){1,2}/i],[PR.PR_PLAIN,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i],[PR.PR_PUNCTUATION,/^[^\s\w\'\"]+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_KEYWORD,/^-?(?:[_a-z]|(?:\\[\da-f]+ ?))(?:[_a-z\d\-]|\\(?:\\[\da-f]+ ?))*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[[PR.PR_STRING,/^[^\)\"\']+/]]),["css-str"]);
diff --git a/tools/ui/node_modules/istanbul-reports/lib/html/index.js b/tools/ui/node_modules/istanbul-reports/lib/html/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d7f7be186337a0330bbd966e995b86d1ffd9a7d
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/html/index.js
@@ -0,0 +1,421 @@
+'use strict';
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const fs = require('fs');
+const path = require('path');
+const html = require('html-escaper');
+const { ReportBase } = require('istanbul-lib-report');
+const annotator = require('./annotator');
+
+function htmlHead(details) {
+ return `
+
+ Code coverage report for ${html.escape(details.entity)}
+
+
+
+
+
+
+
+ `;
+}
+
+function headerTemplate(details) {
+ function metricsTemplate({ pct, covered, total }, kind) {
+ return `
+
+ ${pct}%
+ ${kind}
+ ${covered}/${total}
+
+ `;
+ }
+
+ function skipTemplate(metrics) {
+ const statements = metrics.statements.skipped;
+ const branches = metrics.branches.skipped;
+ const functions = metrics.functions.skipped;
+
+ const countLabel = (c, label, plural) =>
+ c === 0 ? [] : `${c} ${label}${c === 1 ? '' : plural}`;
+ const skips = [].concat(
+ countLabel(statements, 'statement', 's'),
+ countLabel(functions, 'function', 's'),
+ countLabel(branches, 'branch', 'es')
+ );
+
+ if (skips.length === 0) {
+ return '';
+ }
+
+ return `
+
+ ${skips.join(', ')}
+ Ignored
+
+ `;
+ }
+
+ return `
+
+
+${htmlHead(details)}
+
+
+
+
${details.pathHtml}
+
+ ${metricsTemplate(details.metrics.statements, 'Statements')}
+ ${metricsTemplate(details.metrics.branches, 'Branches')}
+ ${metricsTemplate(details.metrics.functions, 'Functions')}
+ ${metricsTemplate(details.metrics.lines, 'Lines')}
+ ${skipTemplate(details.metrics)}
+
+
+ Press n or j to go to the next uncovered block, b, p or k for the previous block.
+
+
+
+ Filter:
+
+
+
+
+
+ `;
+}
+
+function footerTemplate(details) {
+ return `
+
+
`, need control of all whitespace. */
+ return [
+ '',
+ `| ${lineNumbers
+ .map(lineLink)
+ .join('\n')} | `,
+ `${data.lineCoverage
+ .map(lineCount)
+ .join('\n')} | `,
+ `${data.annotatedCode.join(
+ '\n'
+ )} | `,
+ '
'
+ ].join('');
+}
+const summaryTableHeader = [
+ '',
+ '
',
+ '',
+ '',
+ ' | File | ',
+ ' | ',
+ ' Statements | ',
+ ' | ',
+ ' Branches | ',
+ ' | ',
+ ' Functions | ',
+ ' | ',
+ ' Lines | ',
+ ' | ',
+ '
',
+ '',
+ ''
+].join('\n');
+
+function summaryLineTemplate(details) {
+ const { reportClasses, metrics, file, output } = details;
+ const percentGraph = pct => {
+ if (!isFinite(pct)) {
+ return '';
+ }
+
+ const cls = ['cover-fill'];
+ if (pct === 100) {
+ cls.push('cover-full');
+ }
+
+ pct = Math.floor(pct);
+ return [
+ ``,
+ ``
+ ].join('');
+ };
+ const summaryType = (type, showGraph = false) => {
+ const info = metrics[type];
+ const reportClass = reportClasses[type];
+ const result = [
+ `${info.pct}% | `,
+ `${info.covered}/${info.total} | `
+ ];
+ if (showGraph) {
+ result.unshift(
+ ``,
+ ` ${percentGraph(info.pct)} `,
+ ` | `
+ );
+ }
+
+ return result;
+ };
+
+ return []
+ .concat(
+ '',
+ `| ${html.escape(file)} | `,
+ summaryType('statements', true),
+ summaryType('branches'),
+ summaryType('functions'),
+ summaryType('lines'),
+ '
\n'
+ )
+ .join('\n\t');
+}
+
+const summaryTableFooter = ['', '
', '
\n');
+ cw.write(detailTemplate(annotator(node.getFileCoverage(), context)));
+ cw.write('
\n');
+ cw.write(footerTemplate(templateData));
+ cw.close();
+ }
+}
+
+module.exports = HtmlReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/html/insertion-text.js b/tools/ui/node_modules/istanbul-reports/lib/html/insertion-text.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f8064245c2253d8169e4b3fe6a5db111c7398b6
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/html/insertion-text.js
@@ -0,0 +1,114 @@
+'use strict';
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+function InsertionText(text, consumeBlanks) {
+ this.text = text;
+ this.origLength = text.length;
+ this.offsets = [];
+ this.consumeBlanks = consumeBlanks;
+ this.startPos = this.findFirstNonBlank();
+ this.endPos = this.findLastNonBlank();
+}
+
+const WHITE_RE = /[ \f\n\r\t\v\u00A0\u2028\u2029]/;
+
+InsertionText.prototype = {
+ findFirstNonBlank() {
+ let pos = -1;
+ const text = this.text;
+ const len = text.length;
+ let i;
+ for (i = 0; i < len; i += 1) {
+ if (!text.charAt(i).match(WHITE_RE)) {
+ pos = i;
+ break;
+ }
+ }
+ return pos;
+ },
+ findLastNonBlank() {
+ const text = this.text;
+ const len = text.length;
+ let pos = text.length + 1;
+ let i;
+ for (i = len - 1; i >= 0; i -= 1) {
+ if (!text.charAt(i).match(WHITE_RE)) {
+ pos = i;
+ break;
+ }
+ }
+ return pos;
+ },
+ originalLength() {
+ return this.origLength;
+ },
+
+ insertAt(col, str, insertBefore, consumeBlanks) {
+ consumeBlanks =
+ typeof consumeBlanks === 'undefined'
+ ? this.consumeBlanks
+ : consumeBlanks;
+ col = col > this.originalLength() ? this.originalLength() : col;
+ col = col < 0 ? 0 : col;
+
+ if (consumeBlanks) {
+ if (col <= this.startPos) {
+ col = 0;
+ }
+ if (col > this.endPos) {
+ col = this.origLength;
+ }
+ }
+
+ const len = str.length;
+ const offset = this.findOffset(col, len, insertBefore);
+ const realPos = col + offset;
+ const text = this.text;
+ this.text = text.substring(0, realPos) + str + text.substring(realPos);
+ return this;
+ },
+
+ findOffset(pos, len, insertBefore) {
+ const offsets = this.offsets;
+ let offsetObj;
+ let cumulativeOffset = 0;
+ let i;
+
+ for (i = 0; i < offsets.length; i += 1) {
+ offsetObj = offsets[i];
+ if (
+ offsetObj.pos < pos ||
+ (offsetObj.pos === pos && !insertBefore)
+ ) {
+ cumulativeOffset += offsetObj.len;
+ }
+ if (offsetObj.pos >= pos) {
+ break;
+ }
+ }
+ if (offsetObj && offsetObj.pos === pos) {
+ offsetObj.len += len;
+ } else {
+ offsets.splice(i, 0, { pos, len });
+ }
+ return cumulativeOffset;
+ },
+
+ wrap(startPos, startText, endPos, endText, consumeBlanks) {
+ this.insertAt(startPos, startText, true, consumeBlanks);
+ this.insertAt(endPos, endText, false, consumeBlanks);
+ return this;
+ },
+
+ wrapLine(startText, endText) {
+ this.wrap(0, startText, this.originalLength(), endText);
+ },
+
+ toString() {
+ return this.text;
+ }
+};
+
+module.exports = InsertionText;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/json-summary/index.js b/tools/ui/node_modules/istanbul-reports/lib/json-summary/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..318a47faaae29e404b12e41e2e6318232830f5b5
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/json-summary/index.js
@@ -0,0 +1,56 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+class JsonSummaryReport extends ReportBase {
+ constructor(opts) {
+ super();
+
+ this.file = opts.file || 'coverage-summary.json';
+ this.contentWriter = null;
+ this.first = true;
+ }
+
+ onStart(root, context) {
+ this.contentWriter = context.writer.writeFile(this.file);
+ this.contentWriter.write('{');
+ }
+
+ writeSummary(filePath, sc) {
+ const cw = this.contentWriter;
+ if (this.first) {
+ this.first = false;
+ } else {
+ cw.write(',');
+ }
+ cw.write(JSON.stringify(filePath));
+ cw.write(': ');
+ cw.write(JSON.stringify(sc));
+ cw.println('');
+ }
+
+ onSummary(node) {
+ if (!node.isRoot()) {
+ return;
+ }
+ this.writeSummary('total', node.getCoverageSummary());
+ }
+
+ onDetail(node) {
+ this.writeSummary(
+ node.getFileCoverage().path,
+ node.getCoverageSummary()
+ );
+ }
+
+ onEnd() {
+ const cw = this.contentWriter;
+ cw.println('}');
+ cw.close();
+ }
+}
+
+module.exports = JsonSummaryReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/json/index.js b/tools/ui/node_modules/istanbul-reports/lib/json/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcae6aeaf464fd25b4680a1d86125f308d2bbd78
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/json/index.js
@@ -0,0 +1,44 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+class JsonReport extends ReportBase {
+ constructor(opts) {
+ super();
+
+ this.file = opts.file || 'coverage-final.json';
+ this.first = true;
+ }
+
+ onStart(root, context) {
+ this.contentWriter = context.writer.writeFile(this.file);
+ this.contentWriter.write('{');
+ }
+
+ onDetail(node) {
+ const fc = node.getFileCoverage();
+ const key = fc.path;
+ const cw = this.contentWriter;
+
+ if (this.first) {
+ this.first = false;
+ } else {
+ cw.write(',');
+ }
+ cw.write(JSON.stringify(key));
+ cw.write(': ');
+ cw.write(JSON.stringify(fc));
+ cw.println('');
+ }
+
+ onEnd() {
+ const cw = this.contentWriter;
+ cw.println('}');
+ cw.close();
+ }
+}
+
+module.exports = JsonReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/lcov/index.js b/tools/ui/node_modules/istanbul-reports/lib/lcov/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..383c2027c670099f2fc25772dd615e90692bdbf7
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/lcov/index.js
@@ -0,0 +1,33 @@
+'use strict';
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const { ReportBase } = require('istanbul-lib-report');
+const LcovOnlyReport = require('../lcovonly');
+const HtmlReport = require('../html');
+
+class LcovReport extends ReportBase {
+ constructor(opts) {
+ super();
+ this.lcov = new LcovOnlyReport({ file: 'lcov.info', ...opts });
+ this.html = new HtmlReport({ subdir: 'lcov-report' });
+ }
+}
+
+['Start', 'End', 'Summary', 'SummaryEnd', 'Detail'].forEach(what => {
+ const meth = 'on' + what;
+ LcovReport.prototype[meth] = function(...args) {
+ const lcov = this.lcov;
+ const html = this.html;
+
+ if (lcov[meth]) {
+ lcov[meth](...args);
+ }
+ if (html[meth]) {
+ html[meth](...args);
+ }
+ };
+});
+
+module.exports = LcovReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/lcovonly/index.js b/tools/ui/node_modules/istanbul-reports/lib/lcovonly/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..0720e469d7826e71556d5858b5a165b0e2ecd47c
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/lcovonly/index.js
@@ -0,0 +1,77 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+class LcovOnlyReport extends ReportBase {
+ constructor(opts) {
+ super();
+ opts = opts || {};
+ this.file = opts.file || 'lcov.info';
+ this.projectRoot = opts.projectRoot || process.cwd();
+ this.contentWriter = null;
+ }
+
+ onStart(root, context) {
+ this.contentWriter = context.writer.writeFile(this.file);
+ }
+
+ onDetail(node) {
+ const fc = node.getFileCoverage();
+ const writer = this.contentWriter;
+ const functions = fc.f;
+ const functionMap = fc.fnMap;
+ const lines = fc.getLineCoverage();
+ const branches = fc.b;
+ const branchMap = fc.branchMap;
+ const summary = node.getCoverageSummary();
+ const path = require('path');
+
+ writer.println('TN:');
+ const fileName = path.relative(this.projectRoot, fc.path);
+ writer.println('SF:' + fileName);
+
+ Object.values(functionMap).forEach(meta => {
+ // Some versions of the instrumenter in the wild populate 'loc'
+ // but not 'decl':
+ const decl = meta.decl || meta.loc;
+ writer.println('FN:' + [decl.start.line, meta.name].join(','));
+ });
+ writer.println('FNF:' + summary.functions.total);
+ writer.println('FNH:' + summary.functions.covered);
+
+ Object.entries(functionMap).forEach(([key, meta]) => {
+ const stats = functions[key];
+ writer.println('FNDA:' + [stats, meta.name].join(','));
+ });
+
+ Object.entries(lines).forEach(entry => {
+ writer.println('DA:' + entry.join(','));
+ });
+ writer.println('LF:' + summary.lines.total);
+ writer.println('LH:' + summary.lines.covered);
+
+ Object.entries(branches).forEach(([key, branchArray]) => {
+ const meta = branchMap[key];
+ if (meta) {
+ const { line } = meta.loc.start;
+ branchArray.forEach((b, i) => {
+ writer.println('BRDA:' + [line, key, i, b].join(','));
+ });
+ } else {
+ console.warn('Missing coverage entries in', fileName, key);
+ }
+ });
+ writer.println('BRF:' + summary.branches.total);
+ writer.println('BRH:' + summary.branches.covered);
+ writer.println('end_of_record');
+ }
+
+ onEnd() {
+ this.contentWriter.close();
+ }
+}
+
+module.exports = LcovOnlyReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/none/index.js b/tools/ui/node_modules/istanbul-reports/lib/none/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..81c14088c8bb9a73785dbb95cd916ee3e3c9c7a4
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/none/index.js
@@ -0,0 +1,10 @@
+'use strict';
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const { ReportBase } = require('istanbul-lib-report');
+
+class NoneReport extends ReportBase {}
+
+module.exports = NoneReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/teamcity/index.js b/tools/ui/node_modules/istanbul-reports/lib/teamcity/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..2bca26a89dafd82aa7e8e7919eeeb8b2f4f946a3
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/teamcity/index.js
@@ -0,0 +1,67 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+class TeamcityReport extends ReportBase {
+ constructor(opts) {
+ super();
+
+ opts = opts || {};
+ this.file = opts.file || null;
+ this.blockName = opts.blockName || 'Code Coverage Summary';
+ }
+
+ onStart(node, context) {
+ const metrics = node.getCoverageSummary();
+ const cw = context.writer.writeFile(this.file);
+
+ cw.println('');
+ cw.println("##teamcity[blockOpened name='" + this.blockName + "']");
+
+ //Statements Covered
+ cw.println(
+ lineForKey(metrics.statements.covered, 'CodeCoverageAbsBCovered')
+ );
+ cw.println(
+ lineForKey(metrics.statements.total, 'CodeCoverageAbsBTotal')
+ );
+
+ //Branches Covered
+ cw.println(
+ lineForKey(metrics.branches.covered, 'CodeCoverageAbsRCovered')
+ );
+ cw.println(lineForKey(metrics.branches.total, 'CodeCoverageAbsRTotal'));
+
+ //Functions Covered
+ cw.println(
+ lineForKey(metrics.functions.covered, 'CodeCoverageAbsMCovered')
+ );
+ cw.println(
+ lineForKey(metrics.functions.total, 'CodeCoverageAbsMTotal')
+ );
+
+ //Lines Covered
+ cw.println(
+ lineForKey(metrics.lines.covered, 'CodeCoverageAbsLCovered')
+ );
+ cw.println(lineForKey(metrics.lines.total, 'CodeCoverageAbsLTotal'));
+
+ cw.println("##teamcity[blockClosed name='" + this.blockName + "']");
+ cw.close();
+ }
+}
+
+function lineForKey(value, teamcityVar) {
+ return (
+ "##teamcity[buildStatisticValue key='" +
+ teamcityVar +
+ "' value='" +
+ value +
+ "']"
+ );
+}
+
+module.exports = TeamcityReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/text-lcov/index.js b/tools/ui/node_modules/istanbul-reports/lib/text-lcov/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..847aedfd164ac58ad9fb5e59c3643035ae66afed
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/text-lcov/index.js
@@ -0,0 +1,17 @@
+'use strict';
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const LcovOnly = require('../lcovonly');
+
+class TextLcov extends LcovOnly {
+ constructor(opts) {
+ super({
+ ...opts,
+ file: '-'
+ });
+ }
+}
+
+module.exports = TextLcov;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/text-summary/index.js b/tools/ui/node_modules/istanbul-reports/lib/text-summary/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9e6eab3f922a8463e2609a76b4ddb792d325690
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/text-summary/index.js
@@ -0,0 +1,62 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+class TextSummaryReport extends ReportBase {
+ constructor(opts) {
+ super();
+
+ opts = opts || {};
+ this.file = opts.file || null;
+ }
+
+ onStart(node, context) {
+ const summary = node.getCoverageSummary();
+ const cw = context.writer.writeFile(this.file);
+ const printLine = function(key) {
+ const str = lineForKey(summary, key);
+ const clazz = context.classForPercent(key, summary[key].pct);
+ cw.println(cw.colorize(str, clazz));
+ };
+
+ cw.println('');
+ cw.println(
+ '=============================== Coverage summary ==============================='
+ );
+ printLine('statements');
+ printLine('branches');
+ printLine('functions');
+ printLine('lines');
+ cw.println(
+ '================================================================================'
+ );
+ cw.close();
+ }
+}
+
+function lineForKey(summary, key) {
+ const metrics = summary[key];
+
+ key = key.substring(0, 1).toUpperCase() + key.substring(1);
+ if (key.length < 12) {
+ key += ' '.substring(0, 12 - key.length);
+ }
+ const result = [
+ key,
+ ':',
+ metrics.pct + '%',
+ '(',
+ metrics.covered + '/' + metrics.total,
+ ')'
+ ].join(' ');
+ const skipped = metrics.skipped;
+ if (skipped > 0) {
+ return result + ', ' + skipped + ' ignored';
+ }
+ return result;
+}
+
+module.exports = TextSummaryReport;
diff --git a/tools/ui/node_modules/istanbul-reports/lib/text/index.js b/tools/ui/node_modules/istanbul-reports/lib/text/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c28cedb039bf7ad12f2df86d1bc74c5218350146
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/lib/text/index.js
@@ -0,0 +1,298 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE
+ file for terms.
+ */
+'use strict';
+const { ReportBase } = require('istanbul-lib-report');
+
+const NAME_COL = 4;
+const PCT_COLS = 7;
+const MISSING_COL = 17;
+const TAB_SIZE = 1;
+const DELIM = ' | ';
+
+function padding(num, ch) {
+ let str = '';
+ let i;
+ ch = ch || ' ';
+ for (i = 0; i < num; i += 1) {
+ str += ch;
+ }
+ return str;
+}
+
+function fill(str, width, right, tabs) {
+ tabs = tabs || 0;
+ str = String(str);
+
+ const leadingSpaces = tabs * TAB_SIZE;
+ const remaining = width - leadingSpaces;
+ const leader = padding(leadingSpaces);
+ let fmtStr = '';
+
+ if (remaining > 0) {
+ const strlen = str.length;
+ let fillStr;
+
+ if (remaining >= strlen) {
+ fillStr = padding(remaining - strlen);
+ } else {
+ fillStr = '...';
+ const length = remaining - fillStr.length;
+
+ str = str.substring(strlen - length);
+ right = true;
+ }
+ fmtStr = right ? fillStr + str : str + fillStr;
+ }
+
+ return leader + fmtStr;
+}
+
+function formatName(name, maxCols, level) {
+ return fill(name, maxCols, false, level);
+}
+
+function formatPct(pct, width) {
+ return fill(pct, width || PCT_COLS, true, 0);
+}
+
+function nodeMissing(node) {
+ if (node.isSummary()) {
+ return '';
+ }
+
+ const metrics = node.getCoverageSummary();
+ const isEmpty = metrics.isEmpty();
+ const lines = isEmpty ? 0 : metrics.lines.pct;
+
+ let coveredLines;
+
+ const fileCoverage = node.getFileCoverage();
+ if (lines === 100) {
+ const branches = fileCoverage.getBranchCoverageByLine();
+ coveredLines = Object.entries(branches).map(([key, { coverage }]) => [
+ key,
+ coverage === 100
+ ]);
+ } else {
+ coveredLines = Object.entries(fileCoverage.getLineCoverage());
+ }
+
+ let newRange = true;
+ const ranges = coveredLines
+ .reduce((acum, [line, hit]) => {
+ if (hit) newRange = true;
+ else {
+ line = parseInt(line);
+ if (newRange) {
+ acum.push([line]);
+ newRange = false;
+ } else acum[acum.length - 1][1] = line;
+ }
+
+ return acum;
+ }, [])
+ .map(range => {
+ const { length } = range;
+
+ if (length === 1) return range[0];
+
+ return `${range[0]}-${range[1]}`;
+ });
+
+ return [].concat(...ranges).join(',');
+}
+
+function nodeName(node) {
+ return node.getRelativeName() || 'All files';
+}
+
+function depthFor(node) {
+ let ret = 0;
+ node = node.getParent();
+ while (node) {
+ ret += 1;
+ node = node.getParent();
+ }
+ return ret;
+}
+
+function nullDepthFor() {
+ return 0;
+}
+
+function findWidth(node, context, nodeExtractor, depthFor = nullDepthFor) {
+ let last = 0;
+ function compareWidth(node) {
+ last = Math.max(
+ last,
+ TAB_SIZE * depthFor(node) + nodeExtractor(node).length
+ );
+ }
+ const visitor = {
+ onSummary: compareWidth,
+ onDetail: compareWidth
+ };
+ node.visit(context.getVisitor(visitor));
+ return last;
+}
+
+function makeLine(nameWidth, missingWidth) {
+ const name = padding(nameWidth, '-');
+ const pct = padding(PCT_COLS, '-');
+ const elements = [];
+
+ elements.push(name);
+ elements.push(pct);
+ elements.push(padding(PCT_COLS + 1, '-'));
+ elements.push(pct);
+ elements.push(pct);
+ elements.push(padding(missingWidth, '-'));
+ return elements.join(DELIM.replace(/ /g, '-')) + '-';
+}
+
+function tableHeader(maxNameCols, missingWidth) {
+ const elements = [];
+ elements.push(formatName('File', maxNameCols, 0));
+ elements.push(formatPct('% Stmts'));
+ elements.push(formatPct('% Branch', PCT_COLS + 1));
+ elements.push(formatPct('% Funcs'));
+ elements.push(formatPct('% Lines'));
+ elements.push(formatName('Uncovered Line #s', missingWidth));
+ return elements.join(DELIM) + ' ';
+}
+
+function isFull(metrics) {
+ return (
+ metrics.statements.pct === 100 &&
+ metrics.branches.pct === 100 &&
+ metrics.functions.pct === 100 &&
+ metrics.lines.pct === 100
+ );
+}
+
+function tableRow(
+ node,
+ context,
+ colorizer,
+ maxNameCols,
+ level,
+ skipEmpty,
+ skipFull,
+ missingWidth
+) {
+ const name = nodeName(node);
+ const metrics = node.getCoverageSummary();
+ const isEmpty = metrics.isEmpty();
+ if (skipEmpty && isEmpty) {
+ return '';
+ }
+ if (skipFull && isFull(metrics)) {
+ return '';
+ }
+
+ const mm = {
+ statements: isEmpty ? 0 : metrics.statements.pct,
+ branches: isEmpty ? 0 : metrics.branches.pct,
+ functions: isEmpty ? 0 : metrics.functions.pct,
+ lines: isEmpty ? 0 : metrics.lines.pct
+ };
+ const colorize = isEmpty
+ ? function(str) {
+ return str;
+ }
+ : function(str, key) {
+ return colorizer(str, context.classForPercent(key, mm[key]));
+ };
+ const elements = [];
+
+ elements.push(colorize(formatName(name, maxNameCols, level), 'statements'));
+ elements.push(colorize(formatPct(mm.statements), 'statements'));
+ elements.push(colorize(formatPct(mm.branches, PCT_COLS + 1), 'branches'));
+ elements.push(colorize(formatPct(mm.functions), 'functions'));
+ elements.push(colorize(formatPct(mm.lines), 'lines'));
+ elements.push(
+ colorizer(
+ formatName(nodeMissing(node), missingWidth),
+ mm.lines === 100 ? 'medium' : 'low'
+ )
+ );
+
+ return elements.join(DELIM) + ' ';
+}
+
+class TextReport extends ReportBase {
+ constructor(opts) {
+ super(opts);
+
+ opts = opts || {};
+ const { maxCols } = opts;
+
+ this.file = opts.file || null;
+ this.maxCols = maxCols != null ? maxCols : process.stdout.columns || 80;
+ this.cw = null;
+ this.skipEmpty = opts.skipEmpty;
+ this.skipFull = opts.skipFull;
+ }
+
+ onStart(root, context) {
+ this.cw = context.writer.writeFile(this.file);
+ this.nameWidth = Math.max(
+ NAME_COL,
+ findWidth(root, context, nodeName, depthFor)
+ );
+ this.missingWidth = Math.max(
+ MISSING_COL,
+ findWidth(root, context, nodeMissing)
+ );
+
+ if (this.maxCols > 0) {
+ const pct_cols = DELIM.length + 4 * (PCT_COLS + DELIM.length) + 2;
+
+ const maxRemaining = this.maxCols - (pct_cols + MISSING_COL);
+ if (this.nameWidth > maxRemaining) {
+ this.nameWidth = maxRemaining;
+ this.missingWidth = MISSING_COL;
+ } else if (this.nameWidth < maxRemaining) {
+ const maxRemaining = this.maxCols - (this.nameWidth + pct_cols);
+ if (this.missingWidth > maxRemaining) {
+ this.missingWidth = maxRemaining;
+ }
+ }
+ }
+ const line = makeLine(this.nameWidth, this.missingWidth);
+ this.cw.println(line);
+ this.cw.println(tableHeader(this.nameWidth, this.missingWidth));
+ this.cw.println(line);
+ }
+
+ onSummary(node, context) {
+ const nodeDepth = depthFor(node);
+ const row = tableRow(
+ node,
+ context,
+ this.cw.colorize.bind(this.cw),
+ this.nameWidth,
+ nodeDepth,
+ this.skipEmpty,
+ this.skipFull,
+ this.missingWidth
+ );
+ if (row) {
+ this.cw.println(row);
+ }
+ }
+
+ onDetail(node, context) {
+ return this.onSummary(node, context);
+ }
+
+ onEnd() {
+ this.cw.println(makeLine(this.nameWidth, this.missingWidth));
+ this.cw.close();
+ }
+}
+
+module.exports = TextReport;
diff --git a/tools/ui/node_modules/istanbul-reports/package.json b/tools/ui/node_modules/istanbul-reports/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..cc668dd3d2bdc3d78e29210aaffd9bc622762f2e
--- /dev/null
+++ b/tools/ui/node_modules/istanbul-reports/package.json
@@ -0,0 +1,60 @@
+{
+ "name": "istanbul-reports",
+ "version": "3.2.0",
+ "description": "istanbul reports",
+ "author": "Krishnan Anantheswaran ",
+ "main": "index.js",
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "scripts": {
+ "test": "nyc mocha --recursive",
+ "prepare": "webpack --config lib/html-spa/webpack.config.js --mode production",
+ "prepare:watch": "webpack --config lib/html-spa/webpack.config.js --watch --mode development"
+ },
+ "dependencies": {
+ "html-escaper": "^2.0.0",
+ "istanbul-lib-report": "^3.0.0"
+ },
+ "devDependencies": {
+ "@babel/core": "^7.7.5",
+ "@babel/preset-env": "^7.7.5",
+ "@babel/preset-react": "^7.7.4",
+ "babel-loader": "^8.0.6",
+ "chai": "^4.2.0",
+ "is-windows": "^1.0.2",
+ "istanbul-lib-coverage": "^3.0.0",
+ "mocha": "^6.2.2",
+ "nyc": "^15.0.0-beta.2",
+ "react": "^16.12.0",
+ "react-dom": "^16.12.0",
+ "webpack": "^4.41.2",
+ "webpack-cli": "^3.3.10"
+ },
+ "license": "BSD-3-Clause",
+ "repository": {
+ "type": "git",
+ "url": "git+ssh://git@github.com/istanbuljs/istanbuljs.git",
+ "directory": "packages/istanbul-reports"
+ },
+ "keywords": [
+ "istanbul",
+ "reports"
+ ],
+ "bugs": {
+ "url": "https://github.com/istanbuljs/istanbuljs/issues"
+ },
+ "homepage": "https://istanbul.js.org/",
+ "nyc": {
+ "exclude": [
+ "lib/html/assets/**",
+ "lib/html-spa/assets/**",
+ "lib/html-spa/rollup.config.js",
+ "test/**"
+ ]
+ },
+ "engines": {
+ "node": ">=8"
+ }
+}
diff --git a/tools/ui/node_modules/jake/Makefile b/tools/ui/node_modules/jake/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3d0574ece9cbf0b632fd2d2b3010088d98c2047d
--- /dev/null
+++ b/tools/ui/node_modules/jake/Makefile
@@ -0,0 +1,44 @@
+#
+# Jake JavaScript build tool
+# Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+.PHONY: all build install clean uninstall
+
+PREFIX=/usr/local
+DESTDIR=
+
+all: build
+
+build:
+ @echo 'Jake built.'
+
+install:
+ @mkdir -p $(DESTDIR)$(PREFIX)/bin && \
+ mkdir -p $(DESTDIR)$(PREFIX)/lib/node_modules/jake && \
+ mkdir -p ./node_modules && \
+ npm install utilities minimatch && \
+ cp -R ./* $(DESTDIR)$(PREFIX)/lib/node_modules/jake/ && \
+ ln -snf ../lib/node_modules/jake/bin/cli.js $(DESTDIR)$(PREFIX)/bin/jake && \
+ chmod 755 $(DESTDIR)$(PREFIX)/lib/node_modules/jake/bin/cli.js && \
+ echo 'Jake installed.'
+
+clean:
+ @true
+
+uninstall:
+ @rm -f $(DESTDIR)$(PREFIX)/bin/jake && \
+ rm -fr $(DESTDIR)$(PREFIX)/lib/node_modules/jake/ && \
+ echo 'Jake uninstalled.'
diff --git a/tools/ui/node_modules/jake/README.md b/tools/ui/node_modules/jake/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e9388501df15fcff4011bef4b774360fd92e7eb2
--- /dev/null
+++ b/tools/ui/node_modules/jake/README.md
@@ -0,0 +1,17 @@
+### Jake -- the JavaScript build tool for Node.js
+
+[](https://travis-ci.org/jakejs/jake)
+
+Documentation site at [http://jakejs.com](http://jakejs.com/)
+
+### Contributing
+1. [Install node](http://nodejs.org/#download).
+2. Clone this repository `$ git clone git@github.com:jakejs/jake.git`.
+3. Install dependencies `$ npm install`.
+4. Run tests with `$ npm test`.
+5. Start Hacking!
+
+### License
+
+Licensed under the Apache License, Version 2.0
+()
diff --git a/tools/ui/node_modules/jake/bin/bash_completion.sh b/tools/ui/node_modules/jake/bin/bash_completion.sh
new file mode 100644
index 0000000000000000000000000000000000000000..bb259956282db755be455c43b93adc4cee903858
--- /dev/null
+++ b/tools/ui/node_modules/jake/bin/bash_completion.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# http://stackoverflow.com/a/246128
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+ DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+ SOURCE="$(readlink "$SOURCE")"
+ [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+JAKE_BIN_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+# http://stackoverflow.com/a/12495480
+# http://stackoverflow.com/a/28647824
+_auto_jake()
+{
+ local cur
+ local -a COMPGEN=()
+ _get_comp_words_by_ref -n : -c cur
+
+ # run auto-completions in jake via our auto_complete.js wrapper
+ local -a auto_complete_info=( $(export COMP_LINE="${COMP_LINE}" && ${JAKE_BIN_DIR}/auto_complete.js "$cur" "${3}") )
+ # check reply flag
+ local reply_flag="${auto_complete_info[0]}"
+ if [[ "${reply_flag}" == "no-complete" ]]; then
+ return 1
+ fi
+ local auto_completions=("${auto_complete_info[@]:1}")
+ COMPGEN=( $(compgen -W "${auto_completions[*]}" -- "$cur") )
+ COMPREPLY=( "${COMPGEN[@]}" )
+
+ __ltrim_colon_completions "$cur"
+
+ # do we need another space??
+ if [[ "${reply_flag}" == "yes-space" ]]; then
+ COMPREPLY=( "${COMPGEN[@]}" " " )
+ fi
+
+ return 0
+}
+
+complete -o default -F _auto_jake jake
diff --git a/tools/ui/node_modules/jake/bin/cli.js b/tools/ui/node_modules/jake/bin/cli.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f68abbf7fe6f2364781a19f158d7f4d6af894de
--- /dev/null
+++ b/tools/ui/node_modules/jake/bin/cli.js
@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+// Try to load a local jake
+try {
+ require(`${ process.cwd() }/node_modules/jake`);
+}
+// If that fails, likely running globally
+catch(e) {
+ require('../lib/jake');
+}
+
+var args = process.argv.slice(2);
+
+jake.run.apply(jake, args);
diff --git a/tools/ui/node_modules/jake/jakefile.js b/tools/ui/node_modules/jake/jakefile.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a5a55e23cf69eb74265ab07e2f2e59e41aff222
--- /dev/null
+++ b/tools/ui/node_modules/jake/jakefile.js
@@ -0,0 +1,112 @@
+let proc = require('child_process');
+
+const PROJECT_DIR = process.cwd();
+process.env.PROJECT_DIR = PROJECT_DIR;
+
+namespace('doc', function () {
+ task('generate', ['doc:clobber'], function () {
+ var cmd = '../node-jsdoc-toolkit/app/run.js -n -r=100 ' +
+ '-t=../node-jsdoc-toolkit/templates/codeview -d=./doc/ ./lib';
+ jake.logger.log('Generating docs ...');
+ jake.exec([cmd], function () {
+ jake.logger.log('Done.');
+ complete();
+ });
+ }, {async: true});
+
+ task('clobber', function () {
+ var cmd = 'rm -fr ./doc/*';
+ jake.exec([cmd], function () {
+ jake.logger.log('Clobbered old docs.');
+ complete();
+ });
+ }, {async: true});
+
+});
+
+desc('Generate docs for Jake');
+task('doc', ['doc:generate']);
+
+npmPublishTask('jake', function () {
+ this.packageFiles.include([
+ 'Makefile',
+ 'jakefile.js',
+ 'README.md',
+ 'package.json',
+ 'usage.txt',
+ 'lib/**',
+ 'bin/**',
+ 'test/**'
+ ]);
+ this.packageFiles.exclude([
+ 'test/tmp'
+ ]);
+});
+
+jake.Task['publish:package'].directory = PROJECT_DIR;
+
+namespace('test', function () {
+
+ let integrationTest = task('integration', async function () {
+ let testArgs = [];
+ if (process.env.filter) {
+ testArgs.push(process.env.filter);
+ }
+ else {
+ testArgs.push('*.js');
+ }
+ let spawned = proc.spawn(`${PROJECT_DIR}/node_modules/.bin/mocha`, testArgs, {
+ stdio: 'inherit'
+ });
+ return new Promise((resolve, reject) => {
+ spawned.on('exit', () => {
+ resolve();
+ });
+ });
+
+ });
+ integrationTest.directory = `${PROJECT_DIR}/test/integration`;
+
+ let integrationClobber = task('integrationClobber', function () {
+ proc.execSync('rm -rf package.json pkg tmp_publish');
+ });
+ integrationClobber.directory = `${PROJECT_DIR}/test/integration`;
+
+ let unitTest = task('unit', async function () {
+ let testArgs = [];
+ if (process.env.filter) {
+ testArgs.push(process.env.filter);
+ }
+ else {
+ testArgs.push('*.js');
+ }
+ let spawned = proc.spawn(`${PROJECT_DIR}/node_modules/.bin/mocha`, testArgs, {
+ stdio: 'inherit'
+ });
+ });
+ unitTest.directory = `${PROJECT_DIR}/test/unit`;
+
+});
+
+desc('Runs all tests');
+task('test', ['test:unit', 'test:integration', 'test:integrationClobber']);
+
+desc('Runs eslint for both lib and test directories');
+task('lint', function (doFix) {
+
+ let cmd = 'eslint --format codeframe "lib/**/*.js" "test/**/*.js"';
+ if (doFix) {
+ cmd += ' --fix';
+ }
+ try {
+ proc.execSync(cmd);
+ }
+ catch (err) {
+ console.log(err.message);
+ console.log(err.stderr.toString());
+ console.log(err.stdout.toString());
+ fail('eslint failed');
+ }
+});
+
+
diff --git a/tools/ui/node_modules/jake/lib/api.js b/tools/ui/node_modules/jake/lib/api.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f09140eb3031f2049b5e0ce68021ecfaad8a786
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/api.js
@@ -0,0 +1,409 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+let { uuid } = require('./utils');
+
+let api = new (function () {
+ /**
+ @name task
+ @static
+ @function
+ @description Creates a Jake Task
+ `
+ @param {String} name The name of the Task
+ @param {Array} [prereqs] Prerequisites to be run before this task
+ @param {Function} [action] The action to perform for this task
+ @param {Object} [opts]
+ @param {Boolean} [opts.asyc=false] Perform this task asynchronously.
+ If you flag a task with this option, you must call the global
+ `complete` method inside the task's action, for execution to proceed
+ to the next task.
+
+ @example
+ desc('This is the default task.');
+ task('default', function (params) {
+ console.log('This is the default task.');
+ });
+
+ desc('This task has prerequisites.');
+ task('hasPrereqs', ['foo', 'bar', 'baz'], function (params) {
+ console.log('Ran some prereqs first.');
+ });
+
+ desc('This is an asynchronous task.');
+ task('asyncTask', function () {
+ setTimeout(complete, 1000);
+ }, {async: true});
+ */
+ this.task = function (name, prereqs, action, opts) {
+ let args = Array.prototype.slice.call(arguments);
+ let createdTask;
+ args.unshift('task');
+ createdTask = jake.createTask.apply(global, args);
+ jake.currentTaskDescription = null;
+ return createdTask;
+ };
+
+ /**
+ @name rule
+ @static
+ @function
+ @description Creates a Jake Suffix Rule
+ `
+ @param {String} pattern The suffix name of the objective
+ @param {String} source The suffix name of the objective
+ @param {Array} [prereqs] Prerequisites to be run before this task
+ @param {Function} [action] The action to perform for this task
+ @param {Object} [opts]
+ @param {Boolean} [opts.asyc=false] Perform this task asynchronously.
+ If you flag a task with this option, you must call the global
+ `complete` method inside the task's action, for execution to proceed
+ to the next task.
+ @example
+ desc('This is a rule, which does not support namespace or pattern.');
+ rule('.o', '.c', {async: true}, function () {
+ let cmd = util.format('gcc -o %s %s', this.name, this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ desc('This rule has prerequisites.');
+ rule('.o', '.c', ['util.h'], {async: true}, function () {
+ let cmd = util.format('gcc -o %s %s', this.name, this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ desc('This is a rule with patterns.');
+ rule('%.o', '%.c', {async: true}, function () {
+ let cmd = util.format('gcc -o %s %s', this.name, this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ desc('This is another rule with patterns.');
+ rule('obj/%.o', 'src/%.c', {async: true}, function () {
+ let cmd = util.format('gcc -o %s %s', this.name, this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ desc('This is an example with chain rules.');
+ rule('%.pdf', '%.dvi', {async: true}, function () {
+ let cmd = util.format('dvipdfm %s',this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ rule('%.dvi', '%.tex', {async: true}, function () {
+ let cmd = util.format('latex %s',this.source);
+ jake.exec([cmd], function () {
+ complete();
+ }, {printStdout: true});
+ });
+
+ desc('This rule has a namespace.');
+ task('default', ['debug:obj/main.o]);
+
+ namespace('debug', {async: true}, function() {
+ rule('obj/%.o', 'src/%.c', function () {
+ // ...
+ });
+ }
+ */
+ this.rule = function () {
+ let args = Array.prototype.slice.call(arguments);
+ let arg;
+ let pattern = args.shift();
+ let source = args.shift();
+ let prereqs = [];
+ let action = function () {};
+ let opts = {};
+ let key = pattern.toString(); // May be a RegExp
+
+ while ((arg = args.shift())) {
+ if (typeof arg == 'function') {
+ action = arg;
+ }
+ else if (Array.isArray(arg)) {
+ prereqs = arg;
+ }
+ else {
+ opts = arg;
+ }
+ }
+
+ jake.currentNamespace.rules[key] = new jake.Rule({
+ pattern: pattern,
+ source: source,
+ prereqs: prereqs,
+ action: action,
+ opts: opts,
+ desc: jake.currentTaskDescription,
+ ns: jake.currentNamespace
+ });
+ jake.currentTaskDescription = null;
+ };
+
+ /**
+ @name directory
+ @static
+ @function
+ @description Creates a Jake DirectoryTask. Can be used as a prerequisite
+ for FileTasks, or for simply ensuring a directory exists for use with a
+ Task's action.
+ `
+ @param {String} name The name of the DiretoryTask
+
+ @example
+
+ // Creates the package directory for distribution
+ directory('pkg');
+ */
+ this.directory = function (name) {
+ let args = Array.prototype.slice.call(arguments);
+ let createdTask;
+ args.unshift('directory');
+ createdTask = jake.createTask.apply(global, args);
+ jake.currentTaskDescription = null;
+ return createdTask;
+ };
+
+ /**
+ @name file
+ @static
+ @function
+ @description Creates a Jake FileTask.
+ `
+ @param {String} name The name of the FileTask
+ @param {Array} [prereqs] Prerequisites to be run before this task
+ @param {Function} [action] The action to create this file, if it doesn't
+ exist already.
+ @param {Object} [opts]
+ @param {Array} [opts.asyc=false] Perform this task asynchronously.
+ If you flag a task with this option, you must call the global
+ `complete` method inside the task's action, for execution to proceed
+ to the next task.
+
+ */
+ this.file = function (name, prereqs, action, opts) {
+ let args = Array.prototype.slice.call(arguments);
+ let createdTask;
+ args.unshift('file');
+ createdTask = jake.createTask.apply(global, args);
+ jake.currentTaskDescription = null;
+ return createdTask;
+ };
+
+ /**
+ @name desc
+ @static
+ @function
+ @description Creates a description for a Jake Task (or FileTask,
+ DirectoryTask). When invoked, the description that iscreated will
+ be associated with whatever Task is created next.
+ `
+ @param {String} description The description for the Task
+ */
+ this.desc = function (description) {
+ jake.currentTaskDescription = description;
+ };
+
+ /**
+ @name namespace
+ @static
+ @function
+ @description Creates a namespace which allows logical grouping
+ of tasks, and prevents name-collisions with task-names. Namespaces
+ can be nested inside of other namespaces.
+ `
+ @param {String} name The name of the namespace
+ @param {Function} scope The enclosing scope for the namespaced tasks
+
+ @example
+ namespace('doc', function () {
+ task('generate', ['doc:clobber'], function () {
+ // Generate some docs
+ });
+
+ task('clobber', function () {
+ // Clobber the doc directory first
+ });
+ });
+ */
+ this.namespace = function (name, closure) {
+ let curr = jake.currentNamespace;
+ let ns = curr.childNamespaces[name] || new jake.Namespace(name, curr);
+ let fn = closure || function () {};
+ curr.childNamespaces[name] = ns;
+ jake.currentNamespace = ns;
+ fn();
+ jake.currentNamespace = curr;
+ jake.currentTaskDescription = null;
+ return ns;
+ };
+
+ /**
+ @name complete
+ @static
+ @function
+ @description Completes an asynchronous task, allowing Jake's
+ execution to proceed to the next task. Calling complete globally or without
+ arguments completes the last task on the invocationChain. If you use parallel
+ execution of prereqs this will probably complete a wrong task. You should call this
+ function with this task as the first argument, before the optional return value.
+ Alternatively you can call task.complete()
+ `
+ @example
+ task('generate', ['doc:clobber'], function () {
+ exec('./generate_docs.sh', function (err, stdout, stderr) {
+ if (err || stderr) {
+ fail(err || stderr);
+ }
+ else {
+ console.log(stdout);
+ complete();
+ }
+ });
+ }, {async: true});
+ */
+ this.complete = function (task, val) {
+ //this should detect if the first arg is a task, but I guess it should be more thorough
+ if(task && task. _currentPrereqIndex >=0 ) {
+ task.complete(val);
+ }
+ else {
+ val = task;
+ if(jake._invocationChain.length > 0) {
+ jake._invocationChain[jake._invocationChain.length-1].complete(val);
+ }
+ }
+ };
+
+ /**
+ @name fail
+ @static
+ @function
+ @description Causes Jake execution to abort with an error.
+ Allows passing an optional error code, which will be used to
+ set the exit-code of exiting process.
+ `
+ @param {Error|String} err The error to thow when aborting execution.
+ If this argument is an Error object, it will simply be thrown. If
+ a String, it will be used as the error-message. (If it is a multi-line
+ String, the first line will be used as the Error message, and the
+ remaining lines will be used as the error-stack.)
+
+ @example
+ task('createTests, function () {
+ if (!fs.existsSync('./tests')) {
+ fail('Test directory does not exist.');
+ }
+ else {
+ // Do some testing stuff ...
+ }
+ });
+ */
+ this.fail = function (err, code) {
+ let msg;
+ let errObj;
+ if (code) {
+ jake.errorCode = code;
+ }
+ if (err) {
+ if (typeof err == 'string') {
+ // Use the initial or only line of the error as the error-message
+ // If there was a multi-line error, use the rest as the stack
+ msg = err.split('\n');
+ errObj = new Error(msg.shift());
+ if (msg.length) {
+ errObj.stack = msg.join('\n');
+ }
+ throw errObj;
+ }
+ else if (err instanceof Error) {
+ throw err;
+ }
+ else {
+ throw new Error(err.toString());
+ }
+ }
+ else {
+ throw new Error();
+ }
+ };
+
+ this.packageTask = function (name, version, prereqs, definition) {
+ return new jake.PackageTask(name, version, prereqs, definition);
+ };
+
+ this.publishTask = function (name, prereqs, opts, definition) {
+ return new jake.PublishTask(name, prereqs, opts, definition);
+ };
+
+ // Backward-compat
+ this.npmPublishTask = function (name, prereqs, opts, definition) {
+ return new jake.PublishTask(name, prereqs, opts, definition);
+ };
+
+ this.testTask = function () {
+ let ctor = function () {};
+ let t;
+ ctor.prototype = jake.TestTask.prototype;
+ t = new ctor();
+ jake.TestTask.apply(t, arguments);
+ return t;
+ };
+
+ this.setTaskTimeout = function (t) {
+ this._taskTimeout = t;
+ };
+
+ this.setSeriesAutoPrefix = function (prefix) {
+ this._seriesAutoPrefix = prefix;
+ };
+
+ this.series = function (...args) {
+ let prereqs = args.map((arg) => {
+ let name = (this._seriesAutoPrefix || '') + arg.name;
+ jake.task(name, arg);
+ return name;
+ });
+ let seriesName = uuid();
+ let seriesTask = jake.task(seriesName, prereqs);
+ seriesTask._internal = true;
+ let res = function () {
+ return new Promise((resolve) => {
+ seriesTask.invoke();
+ seriesTask.on('complete', (val) => {
+ resolve(val);
+ });
+ });
+ };
+ Object.defineProperty(res, 'name', {value: uuid(),
+ writable: false});
+ return res;
+ };
+
+})();
+
+module.exports = api;
diff --git a/tools/ui/node_modules/jake/lib/jake.js b/tools/ui/node_modules/jake/lib/jake.js
new file mode 100644
index 0000000000000000000000000000000000000000..b395ab9f9841420ebb9a1225f0901386c0006138
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/jake.js
@@ -0,0 +1,330 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+if (!global.jake) {
+
+ let EventEmitter = require('events').EventEmitter;
+ // And so it begins
+ global.jake = new EventEmitter();
+
+ let fs = require('fs');
+ let pc = require('picocolors');
+ let taskNs = require('./task');
+ let Task = taskNs.Task;
+ let FileTask = taskNs.FileTask;
+ let DirectoryTask = taskNs.DirectoryTask;
+ let Rule = require('./rule').Rule;
+ let Namespace = require('./namespace').Namespace;
+ let RootNamespace = require('./namespace').RootNamespace;
+ let api = require('./api');
+ let utils = require('./utils');
+ let Program = require('./program').Program;
+ let loader = require('./loader')();
+ let pkg = JSON.parse(fs.readFileSync(__dirname + '/../package.json').toString());
+
+ const MAX_RULE_RECURSION_LEVEL = 16;
+
+ // Globalize jake and top-level API methods (e.g., `task`, `desc`)
+ Object.assign(global, api);
+
+ // Copy utils onto base jake
+ jake.logger = utils.logger;
+ jake.exec = utils.exec;
+
+ // File utils should be aliased directly on base jake as well
+ Object.assign(jake, utils.file);
+
+ // Also add top-level API methods to exported object for those who don't want to
+ // use the globals (`file` here will overwrite the 'file' utils namespace)
+ Object.assign(jake, api);
+
+ Object.assign(jake, new (function () {
+
+ this._invocationChain = [];
+ this._taskTimeout = 30000;
+
+ // Public properties
+ // =================
+ this.version = pkg.version;
+ // Used when Jake exits with a specific error-code
+ this.errorCode = null;
+ // Loads Jakefiles/jakelibdirs
+ this.loader = loader;
+ // The root of all ... namespaces
+ this.rootNamespace = new RootNamespace();
+ // Non-namespaced tasks are placed into the default
+ this.defaultNamespace = this.rootNamespace;
+ // Start in the default
+ this.currentNamespace = this.defaultNamespace;
+ // Saves the description created by a 'desc' call that prefaces a
+ // 'task' call that defines a task.
+ this.currentTaskDescription = null;
+ this.program = new Program();
+ this.FileList = require('filelist').FileList;
+ this.PackageTask = require('./package_task').PackageTask;
+ this.PublishTask = require('./publish_task').PublishTask;
+ this.TestTask = require('./test_task').TestTask;
+ this.Task = Task;
+ this.FileTask = FileTask;
+ this.DirectoryTask = DirectoryTask;
+ this.Namespace = Namespace;
+ this.Rule = Rule;
+
+ this.parseAllTasks = function () {
+ let _parseNs = function (ns) {
+ let nsTasks = ns.tasks;
+ let nsNamespaces = ns.childNamespaces;
+ for (let q in nsTasks) {
+ let nsTask = nsTasks[q];
+ jake.Task[nsTask.fullName] = nsTask;
+ }
+ for (let p in nsNamespaces) {
+ let nsNamespace = nsNamespaces[p];
+ _parseNs(nsNamespace);
+ }
+ };
+ _parseNs(jake.defaultNamespace);
+ };
+
+ /**
+ * Displays the list of descriptions available for tasks defined in
+ * a Jakefile
+ */
+ this.showAllTaskDescriptions = function (f) {
+ let p;
+ let maxTaskNameLength = 0;
+ let task;
+ let padding;
+ let name;
+ let descr;
+ let filter = typeof f == 'string' ? f : null;
+ let taskParams;
+ let len;
+
+ for (p in jake.Task) {
+ if (!Object.prototype.hasOwnProperty.call(jake.Task, p)) {
+ continue;
+ }
+ if (filter && p.indexOf(filter) == -1) {
+ continue;
+ }
+ task = jake.Task[p];
+ taskParams = task.params;
+
+ // Record the length of the longest task name -- used for
+ // pretty alignment of the task descriptions
+ if (task.description) {
+ len = p.length + taskParams.length;
+ maxTaskNameLength = len > maxTaskNameLength ?
+ len : maxTaskNameLength;
+ }
+ }
+
+ // Print out each entry with descriptions neatly aligned
+ for (p in jake.Task) {
+ if (!Object.prototype.hasOwnProperty.call(jake.Task, p)) {
+ continue;
+ }
+ if (filter && p.indexOf(filter) == -1) {
+ continue;
+ }
+ task = jake.Task[p];
+
+ taskParams = "";
+ if (task.params != "") {
+ taskParams = "[" + task.params + "]";
+ }
+
+ //name = '\033[32m' + p + '\033[39m ';
+ name = pc.green(p);
+
+ descr = task.description;
+ if (descr) {
+ descr = pc.gray('# ' + descr);
+
+ // Create padding-string with calculated length
+ padding = ' '.repeat(maxTaskNameLength - p.length - taskParams.length + 4);
+
+ console.log('jake ' + name + taskParams + padding + descr);
+ }
+ }
+ };
+
+ this.createTask = function () {
+ let args = Array.prototype.slice.call(arguments);
+ let arg;
+ let obj;
+ let task;
+ let type;
+ let name;
+ let action;
+ let opts = {};
+ let prereqs = [];
+
+ type = args.shift();
+
+ // name, [deps], [action]
+ // Name (string) + deps (array) format
+ if (typeof args[0] == 'string') {
+ name = args.shift();
+ if (Array.isArray(args[0])) {
+ prereqs = args.shift();
+ }
+ }
+ // name:deps, [action]
+ // Legacy object-literal syntax, e.g.: {'name': ['depA', 'depB']}
+ else {
+ obj = args.shift();
+ for (let p in obj) {
+ prereqs = prereqs.concat(obj[p]);
+ name = p;
+ }
+ }
+
+ // Optional opts/callback or callback/opts
+ while ((arg = args.shift())) {
+ if (typeof arg == 'function') {
+ action = arg;
+ }
+ else {
+ opts = Object.assign(Object.create(null), arg);
+ }
+ }
+
+ task = jake.currentNamespace.resolveTask(name);
+ if (task && !action) {
+ // Task already exists and no action, just update prereqs, and return it.
+ task.prereqs = task.prereqs.concat(prereqs);
+ return task;
+ }
+
+ switch (type) {
+ case 'directory':
+ action = function action() {
+ jake.mkdirP(name);
+ };
+ task = new DirectoryTask(name, prereqs, action, opts);
+ break;
+ case 'file':
+ task = new FileTask(name, prereqs, action, opts);
+ break;
+ default:
+ task = new Task(name, prereqs, action, opts);
+ }
+
+ jake.currentNamespace.addTask(task);
+
+ if (jake.currentTaskDescription) {
+ task.description = jake.currentTaskDescription;
+ jake.currentTaskDescription = null;
+ }
+
+ // FIXME: Should only need to add a new entry for the current
+ // task-definition, not reparse the entire structure
+ jake.parseAllTasks();
+
+ return task;
+ };
+
+ this.attemptRule = function (name, ns, level) {
+ let prereqRule;
+ let prereq;
+ if (level > MAX_RULE_RECURSION_LEVEL) {
+ return null;
+ }
+ // Check Rule
+ prereqRule = ns.matchRule(name);
+ if (prereqRule) {
+ prereq = prereqRule.createTask(name, level);
+ }
+ return prereq || null;
+ };
+
+ this.createPlaceholderFileTask = function (name, namespace) {
+ let parsed = name.split(':');
+ let filePath = parsed.pop(); // Strip any namespace
+ let task;
+
+ task = namespace.resolveTask(name);
+
+ // If there's not already an existing dummy FileTask for it,
+ // create one
+ if (!task) {
+ // Create a dummy FileTask only if file actually exists
+ if (fs.existsSync(filePath)) {
+ task = new jake.FileTask(filePath);
+ task.dummy = true;
+ let ns;
+ if (parsed.length) {
+ ns = namespace.resolveNamespace(parsed.join(':'));
+ }
+ else {
+ ns = namespace;
+ }
+ if (!namespace) {
+ throw new Error('Invalid namespace, cannot add FileTask');
+ }
+ ns.addTask(task);
+ // Put this dummy Task in the global Tasks list so
+ // modTime will be eval'd correctly
+ jake.Task[`${ns.path}:${filePath}`] = task;
+ }
+ }
+
+ return task || null;
+ };
+
+
+ this.run = function () {
+ let args = Array.prototype.slice.call(arguments);
+ let program = this.program;
+ let loader = this.loader;
+ let preempt;
+ let opts;
+
+ program.parseArgs(args);
+ program.init();
+
+ preempt = program.firstPreemptiveOption();
+ if (preempt) {
+ preempt();
+ }
+ else {
+ opts = program.opts;
+ // jakefile flag set but no jakefile yet
+ if (opts.autocomplete && opts.jakefile === true) {
+ process.stdout.write('no-complete');
+ return;
+ }
+ // Load Jakefile and jakelibdir files
+ let jakefileLoaded = loader.loadFile(opts.jakefile);
+ let jakelibdirLoaded = loader.loadDirectory(opts.jakelibdir);
+
+ if(!jakefileLoaded && !jakelibdirLoaded && !opts.autocomplete) {
+ fail('No Jakefile. Specify a valid path with -f/--jakefile, ' +
+ 'or place one in the current directory.');
+ }
+
+ program.run();
+ }
+ };
+
+ })());
+}
+
+module.exports = jake;
diff --git a/tools/ui/node_modules/jake/lib/loader.js b/tools/ui/node_modules/jake/lib/loader.js
new file mode 100644
index 0000000000000000000000000000000000000000..28e0a3d9febb2b7a8bf28dcba5966db8dd844797
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/loader.js
@@ -0,0 +1,174 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let path = require('path');
+let fs = require('fs');
+let existsSync = fs.existsSync;
+let utils = require('./utils');
+
+// Files like jakelib/foobar.jake.js
+const JAKELIB_FILE_PAT = /\.jake$|\.js$/;
+const SUPPORTED_EXTENSIONS = {
+ 'js': null,
+ 'cjs': null,
+ 'coffee': function () {
+ try {
+ let cs = require('coffeescript');
+ if (typeof cs.register == 'function') {
+ cs.register();
+ }
+ }
+ catch(e) {
+ throw new Error('You have a CoffeeScript Jakefile, but have not installed CoffeeScript');
+ }
+ },
+ 'ls': function () {
+ try {
+ require('livescript');
+ }
+ catch (e) {
+ throw new Error('You have a LiveScript Jakefile, but have not installed LiveScript');
+ }
+ },
+ 'ts': function () {
+ try {
+ require('ts-node/register/transpile-only');
+ }
+ catch (e) {
+ throw new Error('You have a TypeScript Jakefile, but have not installed TypeScript and ts-node');
+ }
+ }
+};
+const IMPLICIT_JAKEFILE_NAMES = [
+ 'Jakefile',
+ 'Gulpfile'
+];
+
+let Loader = function () {
+ // Load a Jakefile, running the code inside -- this may result in
+ // tasks getting defined using the original Jake API, e.g.,
+ // `task('foo' ['bar', 'baz']);`, or can also auto-create tasks
+ // from any functions exported from the file
+ function loadFile(filePath) {
+ let exported = require(filePath);
+ for (let [key, value] of Object.entries(exported)) {
+ let t;
+ if (typeof value == 'function') {
+ t = jake.task(key, value);
+ t.description = '(Exported function)';
+ }
+ }
+ }
+
+ function fileExists(name) {
+ let nameWithExt = null;
+ // Support no file extension as well
+ let exts = Object.keys(SUPPORTED_EXTENSIONS).concat(['']);
+ exts.some((ext) => {
+ let fname = ext ? `${name}.${ext}` : name;
+ if (existsSync(fname)) {
+ nameWithExt = fname;
+ return true;
+ }
+ });
+ return nameWithExt;
+ }
+
+ // Recursive
+ function findImplicitJakefile() {
+ let cwd = process.cwd();
+ let names = IMPLICIT_JAKEFILE_NAMES;
+ let found = null;
+ names.some((name) => {
+ let n;
+ // Prefer all-lowercase
+ n = name.toLowerCase();
+ if ((found = fileExists(n))) {
+ return found;
+ }
+ // Check mixed-case as well
+ n = name;
+ if ((found = fileExists(n))) {
+ return found;
+ }
+ });
+ if (found) {
+ return found;
+ }
+ else {
+ process.chdir("..");
+ // If we've walked all the way up the directory tree,
+ // bail out with no result
+ if (cwd === process.cwd()) {
+ return null;
+ }
+ return findImplicitJakefile();
+ }
+ }
+
+ this.loadFile = function (fileSpecified) {
+ let jakefile;
+ let origCwd = process.cwd();
+
+ if (fileSpecified) {
+ if (existsSync(fileSpecified)) {
+ jakefile = fileSpecified;
+ }
+ }
+ else {
+ jakefile = findImplicitJakefile();
+ }
+
+ if (jakefile) {
+ let ext = jakefile.split('.')[1];
+ let loaderFunc = SUPPORTED_EXTENSIONS[ext];
+ loaderFunc && loaderFunc();
+
+ loadFile(utils.file.absolutize(jakefile));
+ return true;
+ }
+ else {
+ if (!fileSpecified) {
+ // Restore the working directory on failure
+ process.chdir(origCwd);
+ }
+ return false;
+ }
+ };
+
+ this.loadDirectory = function (d) {
+ let dirname = d || 'jakelib';
+ let dirlist;
+ dirname = utils.file.absolutize(dirname);
+ if (existsSync(dirname)) {
+ dirlist = fs.readdirSync(dirname);
+ dirlist.forEach(function (filePath) {
+ if (JAKELIB_FILE_PAT.test(filePath)) {
+ loadFile(path.join(dirname, filePath));
+ }
+ });
+ return true;
+ }
+ return false;
+ };
+
+};
+
+module.exports = function () {
+ return new Loader();
+};
diff --git a/tools/ui/node_modules/jake/lib/namespace.js b/tools/ui/node_modules/jake/lib/namespace.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3c2787a77a841b171c38a4f487d66eb1cd78ce0
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/namespace.js
@@ -0,0 +1,115 @@
+const ROOT_NAMESPACE_NAME = '__rootNamespace__';
+
+class Namespace {
+ constructor(name, parentNamespace) {
+ this.name = name;
+ this.parentNamespace = parentNamespace;
+ this.childNamespaces = {};
+ this.tasks = {};
+ this.rules = {};
+ this.path = this.getPath();
+ }
+
+ get fullName() {
+ return this._getFullName();
+ }
+
+ addTask(task) {
+ this.tasks[task.name] = task;
+ task.namespace = this;
+ }
+
+ resolveTask(name) {
+ if (!name) {
+ return;
+ }
+
+ let taskPath = name.split(':');
+ let taskName = taskPath.pop();
+ let task;
+ let ns;
+
+ // Namespaced, return either relative to current, or from root
+ if (taskPath.length) {
+ taskPath = taskPath.join(':');
+ ns = this.resolveNamespace(taskPath) ||
+ Namespace.ROOT_NAMESPACE.resolveNamespace(taskPath);
+ task = (ns && ns.resolveTask(taskName));
+ }
+ // Bare task, return either local, or top-level
+ else {
+ task = this.tasks[name] || Namespace.ROOT_NAMESPACE.tasks[name];
+ }
+
+ return task || null;
+ }
+
+
+ resolveNamespace(relativeName) {
+ if (!relativeName) {
+ return this;
+ }
+
+ let parts = relativeName.split(':');
+ let ns = this;
+
+ for (let i = 0, ii = parts.length; (ns && i < ii); i++) {
+ ns = ns.childNamespaces[parts[i]];
+ }
+
+ return ns || null;
+ }
+
+ matchRule(relativeName) {
+ let parts = relativeName.split(':');
+ parts.pop();
+ let ns = this.resolveNamespace(parts.join(':'));
+ let rules = ns ? ns.rules : [];
+ let r;
+ let match;
+
+ for (let p in rules) {
+ r = rules[p];
+ if (r.match(relativeName)) {
+ match = r;
+ }
+ }
+
+ return (ns && match) ||
+ (this.parentNamespace &&
+ this.parentNamespace.matchRule(relativeName));
+ }
+
+ getPath() {
+ let parts = [];
+ let next = this.parentNamespace;
+ while (next) {
+ parts.push(next.name);
+ next = next.parentNamespace;
+ }
+ parts.pop(); // Remove '__rootNamespace__'
+ return parts.reverse().join(':');
+ }
+
+ _getFullName() {
+ let path = this.path;
+ path = (path && path.split(':')) || [];
+ path.push(this.name);
+ return path.join(':');
+ }
+
+ isRootNamespace() {
+ return !this.parentNamespace;
+ }
+}
+
+class RootNamespace extends Namespace {
+ constructor() {
+ super(ROOT_NAMESPACE_NAME, null);
+ Namespace.ROOT_NAMESPACE = this;
+ }
+}
+
+module.exports.Namespace = Namespace;
+module.exports.RootNamespace = RootNamespace;
+
diff --git a/tools/ui/node_modules/jake/lib/package_task.js b/tools/ui/node_modules/jake/lib/package_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..527aca70e380f8dd04bd1b49877a263d0bdf8ea8
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/package_task.js
@@ -0,0 +1,406 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let path = require('path');
+let fs = require('fs');
+let exec = require('child_process').exec;
+let FileList = require('filelist').FileList;
+
+/**
+ @name jake
+ @namespace jake
+*/
+/**
+ @name jake.PackageTask
+ @constructor
+ @description Instantiating a PackageTask creates a number of Jake
+ Tasks that make packaging and distributing your software easy.
+
+ @param {String} name The name of the project
+ @param {String} version The current project version (will be
+ appended to the project-name in the package-archive
+ @param {Function} definition Defines the contents of the package,
+ and format of the package-archive. Will be executed on the instantiated
+ PackageTask (i.e., 'this', will be the PackageTask instance),
+ to set the various instance-propertiess.
+
+ @example
+ let t = new jake.PackageTask('rous', 'v' + version, function () {
+ let files = [
+ 'Capfile'
+ , 'Jakefile'
+ , 'README.md'
+ , 'package.json'
+ , 'app/*'
+ , 'bin/*'
+ , 'config/*'
+ , 'lib/*'
+ , 'node_modules/*'
+ ];
+ this.packageFiles.include(files);
+ this.packageFiles.exclude('node_modules/foobar');
+ this.needTarGz = true;
+ });
+
+ */
+let PackageTask = function () {
+ let args = Array.prototype.slice.call(arguments);
+ let name = args.shift();
+ let version = args.shift();
+ let definition = args.pop();
+ let prereqs = args.pop() || []; // Optional
+
+ prereqs = [].concat(prereqs); // Accept string or list
+
+ /**
+ @name jake.PackageTask#name
+ @public
+ @type {String}
+ @description The name of the project
+ */
+ this.name = name;
+ /**
+ @name jake.PackageTask#version
+ @public
+ @type {String}
+ @description The project version-string
+ */
+ this.version = version;
+ /**
+ @name jake.PackageTask#prereqs
+ @public
+ @type {Array}
+ @description Tasks to run before packaging
+ */
+ this.prereqs = prereqs;
+ /**
+ @name jake.PackageTask#packageDir
+ @public
+ @type {String='pkg'}
+ @description The directory-name to use for packaging the software
+ */
+ this.packageDir = 'pkg';
+ /**
+ @name jake.PackageTask#packageFiles
+ @public
+ @type {jake.FileList}
+ @description The list of files and directories to include in the
+ package-archive
+ */
+ this.packageFiles = new FileList();
+ /**
+ @name jake.PackageTask#needTar
+ @public
+ @type {Boolean=false}
+ @description If set to true, uses the `tar` utility to create
+ a gzip .tgz archive of the package
+ */
+ this.needTar = false;
+ /**
+ @name jake.PackageTask#needTarGz
+ @public
+ @type {Boolean=false}
+ @description If set to true, uses the `tar` utility to create
+ a gzip .tar.gz archive of the package
+ */
+ this.needTarGz = false;
+ /**
+ @name jake.PackageTask#needTarBz2
+ @public
+ @type {Boolean=false}
+ @description If set to true, uses the `tar` utility to create
+ a bzip2 .bz2 archive of the package
+ */
+ this.needTarBz2 = false;
+ /**
+ @name jake.PackageTask#needJar
+ @public
+ @type {Boolean=false}
+ @description If set to true, uses the `jar` utility to create
+ a .jar archive of the package
+ */
+ this.needJar = false;
+ /**
+ @name jake.PackageTask#needZip
+ @public
+ @type {Boolean=false}
+ @description If set to true, uses the `zip` utility to create
+ a .zip archive of the package
+ */
+ this.needZip = false;
+ /**
+ @name jake.PackageTask#manifestFile
+ @public
+ @type {String=null}
+ @description Can be set to point the `jar` utility at a manifest
+ file to use in a .jar archive. If unset, one will be automatically
+ created by the `jar` utility. This path should be relative to the
+ root of the package directory (this.packageDir above, likely 'pkg')
+ */
+ this.manifestFile = null;
+ /**
+ @name jake.PackageTask#tarCommand
+ @public
+ @type {String='tar'}
+ @description The shell-command to use for creating tar archives.
+ */
+ this.tarCommand = 'tar';
+ /**
+ @name jake.PackageTask#jarCommand
+ @public
+ @type {String='jar'}
+ @description The shell-command to use for creating jar archives.
+ */
+ this.jarCommand = 'jar';
+ /**
+ @name jake.PackageTask#zipCommand
+ @public
+ @type {String='zip'}
+ @description The shell-command to use for creating zip archives.
+ */
+ this.zipCommand = 'zip';
+ /**
+ @name jake.PackageTask#archiveNoBaseDir
+ @public
+ @type {Boolean=false}
+ @description Simple option for performing the archive on the
+ contents of the directory instead of the directory itself
+ */
+ this.archiveNoBaseDir = false;
+ /**
+ @name jake.PackageTask#archiveChangeDir
+ @public
+ @type {String=null}
+ @description Equivalent to the '-C' command for the `tar` and `jar`
+ commands. ("Change to this directory before adding files.")
+ */
+ this.archiveChangeDir = null;
+ /**
+ @name jake.PackageTask#archiveContentDir
+ @public
+ @type {String=null}
+ @description Specifies the files and directories to include in the
+ package-archive. If unset, this will default to the main package
+ directory -- i.e., name + version.
+ */
+ this.archiveContentDir = null;
+
+ if (typeof definition == 'function') {
+ definition.call(this);
+ }
+ this.define();
+};
+
+PackageTask.prototype = new (function () {
+
+ let _compressOpts = {
+ Tar: {
+ ext: '.tgz',
+ flags: 'czf',
+ cmd: 'tar'
+ },
+ TarGz: {
+ ext: '.tar.gz',
+ flags: 'czf',
+ cmd: 'tar'
+ },
+ TarBz2: {
+ ext: '.tar.bz2',
+ flags: 'cjf',
+ cmd: 'tar'
+ },
+ Jar: {
+ ext: '.jar',
+ flags: 'cf',
+ cmd: 'jar'
+ },
+ Zip: {
+ ext: '.zip',
+ flags: 'qr',
+ cmd: 'zip'
+ }
+ };
+
+ this.define = function () {
+ let self = this;
+ let packageDirPath = this.packageDirPath();
+ let compressTaskArr = [];
+
+ desc('Build the package for distribution');
+ task('package', self.prereqs.concat(['clobberPackage', 'buildPackage']));
+ // Backward-compat alias
+ task('repackage', ['package']);
+
+ task('clobberPackage', function () {
+ jake.rmRf(self.packageDir, {silent: true});
+ });
+
+ desc('Remove the package');
+ task('clobber', ['clobberPackage']);
+
+ let doCommand = function (p) {
+ let filename = path.resolve(self.packageDir + '/' + self.packageName() +
+ _compressOpts[p].ext);
+ if (process.platform == 'win32') {
+ // Windows full path may have drive letter, which is going to cause
+ // namespace problems, so strip it.
+ if (filename.length > 2 && filename[1] == ':') {
+ filename = filename.substr(2);
+ }
+ }
+ compressTaskArr.push(filename);
+
+ file(filename, [packageDirPath], function () {
+ let cmd;
+ let opts = _compressOpts[p];
+ // Directory to move to when doing the compression-task
+ // Changes in the case of zip for emulating -C option
+ let chdir = self.packageDir;
+ // Save the current dir so it's possible to pop back up
+ // after compressing
+ let currDir = process.cwd();
+ let archiveChangeDir;
+ let archiveContentDir;
+
+ if (self.archiveNoBaseDir) {
+ archiveChangeDir = self.packageName();
+ archiveContentDir = '.';
+ }
+ else {
+ archiveChangeDir = self.archiveChangeDir;
+ archiveContentDir = self.archiveContentDir;
+ }
+
+ cmd = self[opts.cmd + 'Command'];
+ cmd += ' -' + opts.flags;
+ if (opts.cmd == 'jar' && self.manifestFile) {
+ cmd += 'm';
+ }
+
+ // The name of the archive to create -- use full path
+ // so compression can be performed from a different dir
+ // if needed
+ cmd += ' ' + filename;
+
+ if (opts.cmd == 'jar' && self.manifestFile) {
+ cmd += ' ' + self.manifestFile;
+ }
+
+ // Where to perform the compression -- -C option isn't
+ // supported in zip, so actually do process.chdir for this
+ if (archiveChangeDir) {
+ if (opts.cmd == 'zip') {
+ chdir = path.join(chdir, archiveChangeDir);
+ }
+ else {
+ cmd += ' -C ' + archiveChangeDir;
+ }
+ }
+
+ // Where to get the archive content
+ if (archiveContentDir) {
+ cmd += ' ' + archiveContentDir;
+ }
+ else {
+ cmd += ' ' + self.packageName();
+ }
+
+ // Move into the desired dir (usually packageDir) to compress
+ // Return back up to the current dir after the exec
+ process.chdir(chdir);
+
+ exec(cmd, function (err, stdout, stderr) {
+ if (err) { throw err; }
+
+ // Return back up to the starting directory (see above,
+ // before exec)
+ process.chdir(currDir);
+
+ complete();
+ });
+ }, {async: true});
+ };
+
+ for (let p in _compressOpts) {
+ if (this['need' + p]) {
+ doCommand(p);
+ }
+ }
+
+ task('buildPackage', compressTaskArr, function () {});
+
+ directory(this.packageDir);
+
+ file(packageDirPath, this.packageFiles, function () {
+ jake.mkdirP(packageDirPath);
+ let fileList = [];
+ self.packageFiles.forEach(function (name) {
+ let f = path.join(self.packageDirPath(), name);
+ let fDir = path.dirname(f);
+ jake.mkdirP(fDir, {silent: true});
+
+ // Add both files and directories
+ fileList.push({
+ from: name,
+ to: f
+ });
+ });
+ let _copyFile = function () {
+ let file = fileList.pop();
+ let stat;
+ if (file) {
+ stat = fs.statSync(file.from);
+ // Target is a directory, just create it
+ if (stat.isDirectory()) {
+ jake.mkdirP(file.to, {silent: true});
+ _copyFile();
+ }
+ // Otherwise copy the file
+ else {
+ jake.cpR(file.from, file.to, {silent: true});
+ _copyFile();
+ }
+ }
+ else {
+ complete();
+ }
+ };
+ _copyFile();
+ }, {async: true});
+
+
+ };
+
+ this.packageName = function () {
+ if (this.version) {
+ return this.name + '-' + this.version;
+ }
+ else {
+ return this.name;
+ }
+ };
+
+ this.packageDirPath = function () {
+ return this.packageDir + '/' + this.packageName();
+ };
+
+})();
+
+jake.PackageTask = PackageTask;
+exports.PackageTask = PackageTask;
+
diff --git a/tools/ui/node_modules/jake/lib/parseargs.js b/tools/ui/node_modules/jake/lib/parseargs.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a00733410eb3b21bedba4a61d82a903bd1e73f3
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/parseargs.js
@@ -0,0 +1,134 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let parseargs = {};
+let isOpt = function (arg) { return arg.indexOf('-') === 0; };
+let removeOptPrefix = function (opt) { return opt.replace(/^--/, '').replace(/^-/, ''); };
+
+/**
+ * @constructor
+ * Parses a list of command-line args into a key/value object of
+ * options and an array of positional commands.
+ * @ param {Array} opts A list of options in the following format:
+ * [{full: 'foo', abbr: 'f'}, {full: 'bar', abbr: 'b'}]]
+ */
+parseargs.Parser = function (opts) {
+ // A key/value object of matching options parsed out of the args
+ this.opts = {};
+ this.taskNames = null;
+ this.envVars = null;
+
+ // Data structures used for parsing
+ this.reg = opts;
+ this.shortOpts = {};
+ this.longOpts = {};
+
+ let self = this;
+ [].forEach.call(opts, function (item) {
+ self.shortOpts[item.abbr] = item;
+ self.longOpts[item.full] = item;
+ });
+};
+
+parseargs.Parser.prototype = new function () {
+
+ let _trueOrNextVal = function (argParts, args) {
+ if (argParts[1]) {
+ return argParts[1];
+ }
+ else {
+ return (!args[0] || isOpt(args[0])) ?
+ true : args.shift();
+ }
+ };
+
+ /**
+ * Parses an array of arguments into options and positional commands
+ * @param {Array} args The command-line args to parse
+ */
+ this.parse = function (args) {
+ let cmds = [];
+ let cmd;
+ let envVars = {};
+ let opts = {};
+ let arg;
+ let argItem;
+ let argParts;
+ let cmdItems;
+ let taskNames = [];
+ let preempt;
+
+ while (args.length) {
+ arg = args.shift();
+
+ if (isOpt(arg)) {
+ arg = removeOptPrefix(arg);
+ argParts = arg.split('=');
+ argItem = this.longOpts[argParts[0]] || this.shortOpts[argParts[0]];
+ if (argItem) {
+ // First-encountered preemptive opt takes precedence -- no further opts
+ // or possibility of ambiguity, so just look for a value, or set to
+ // true and then bail
+ if (argItem.preempts) {
+ opts[argItem.full] = _trueOrNextVal(argParts, args);
+ preempt = true;
+ break;
+ }
+ // If the opt requires a value, see if we can get a value from the
+ // next arg, or infer true from no-arg -- if it's followed by another
+ // opt, throw an error
+ if (argItem.expectValue || argItem.allowValue) {
+ opts[argItem.full] = _trueOrNextVal(argParts, args);
+ if (argItem.expectValue && !opts[argItem.full]) {
+ throw new Error(argItem.full + ' option expects a value.');
+ }
+ }
+ else {
+ opts[argItem.full] = true;
+ }
+ }
+ }
+ else {
+ cmds.unshift(arg);
+ }
+ }
+
+ if (!preempt) {
+ // Parse out any env-vars and task-name
+ while ((cmd = cmds.pop())) {
+ cmdItems = cmd.split('=');
+ if (cmdItems.length > 1) {
+ envVars[cmdItems[0]] = cmdItems[1];
+ }
+ else {
+ taskNames.push(cmd);
+ }
+ }
+
+ }
+
+ return {
+ opts: opts,
+ envVars: envVars,
+ taskNames: taskNames
+ };
+ };
+
+};
+
+module.exports = parseargs;
diff --git a/tools/ui/node_modules/jake/lib/program.js b/tools/ui/node_modules/jake/lib/program.js
new file mode 100644
index 0000000000000000000000000000000000000000..121632fb18b38d4bad5e6bec1bb8ec5d86aa3bd8
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/program.js
@@ -0,0 +1,282 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let fs = require('fs');
+let parseargs = require('./parseargs');
+let utils = require('./utils');
+let Program;
+let usage = require('fs').readFileSync(`${__dirname}/../usage.txt`).toString();
+let { Task } = require('./task/task');
+
+function die(msg) {
+ console.log(msg);
+ process.stdout.write('', function () {
+ process.stderr.write('', function () {
+ process.exit();
+ });
+ });
+}
+
+let preempts = {
+ version: function () {
+ die(jake.version);
+ },
+ help: function () {
+ die(usage);
+ }
+};
+
+let AVAILABLE_OPTS = [
+ { full: 'jakefile',
+ abbr: 'f',
+ expectValue: true
+ },
+ { full: 'quiet',
+ abbr: 'q',
+ expectValue: false
+ },
+ { full: 'directory',
+ abbr: 'C',
+ expectValue: true
+ },
+ { full: 'always-make',
+ abbr: 'B',
+ expectValue: false
+ },
+ { full: 'tasks',
+ abbr: 'T',
+ expectValue: false,
+ allowValue: true
+ },
+ // Alias t
+ { full: 'tasks',
+ abbr: 't',
+ expectValue: false,
+ allowValue: true
+ },
+ // Alias ls
+ { full: 'tasks',
+ abbr: 'ls',
+ expectValue: false,
+ allowValue: true
+ },
+ { full: 'help',
+ abbr: 'h',
+ },
+ { full: 'version',
+ abbr: 'V',
+ },
+ // Alias lowercase v
+ { full: 'version',
+ abbr: 'v',
+ },
+ { full: 'jakelibdir',
+ abbr: 'J',
+ expectValue: true
+ },
+ { full: 'allow-rejection',
+ abbr: 'ar',
+ expectValue: false
+ }
+];
+
+Program = function () {
+ this.availableOpts = AVAILABLE_OPTS;
+ this.opts = {};
+ this.taskNames = null;
+ this.taskArgs = null;
+ this.envVars = null;
+ this.die = die;
+};
+
+Program.prototype = new (function () {
+
+ this.handleErr = function (err) {
+ if (jake.listeners('error').length !== 0) {
+ jake.emit('error', err);
+ return;
+ }
+
+ if (jake.listeners('error').length) {
+ jake.emit('error', err);
+ return;
+ }
+
+ utils.logger.error('jake aborted.');
+ if (err.stack) {
+ utils.logger.error(err.stack);
+ }
+ else {
+ utils.logger.error(err.message);
+ }
+
+ process.stdout.write('', function () {
+ process.stderr.write('', function () {
+ jake.errorCode = jake.errorCode || 1;
+ process.exit(jake.errorCode);
+ });
+ });
+ };
+
+ this.parseArgs = function (args) {
+ let result = (new parseargs.Parser(this.availableOpts)).parse(args);
+ this.setOpts(result.opts);
+ this.setTaskNames(result.taskNames);
+ this.setEnvVars(result.envVars);
+ };
+
+ this.setOpts = function (options) {
+ let opts = options || {};
+ Object.assign(this.opts, opts);
+ };
+
+ this.internalOpts = function (options) {
+ this.availableOpts = this.availableOpts.concat(options);
+ };
+
+ this.autocompletions = function (cur) {
+ let p; let i; let task;
+ let commonPrefix = '';
+ let matches = [];
+
+ for (p in jake.Task) {
+ task = jake.Task[p];
+ if (
+ 'fullName' in task
+ && (
+ // if empty string, program converts to true
+ cur === true ||
+ task.fullName.indexOf(cur) === 0
+ )
+ ) {
+ if (matches.length === 0) {
+ commonPrefix = task.fullName;
+ }
+ else {
+ for (i = commonPrefix.length; i > -1; --i) {
+ commonPrefix = commonPrefix.substr(0, i);
+ if (task.fullName.indexOf(commonPrefix) === 0) {
+ break;
+ }
+ }
+ }
+ matches.push(task.fullName);
+ }
+ }
+
+ if (matches.length > 1 && commonPrefix === cur) {
+ matches.unshift('yes-space');
+ }
+ else {
+ matches.unshift('no-space');
+ }
+
+ process.stdout.write(matches.join(' '));
+ };
+
+ this.setTaskNames = function (names) {
+ if (names && !Array.isArray(names)) {
+ throw new Error('Task names must be an array');
+ }
+ this.taskNames = (names && names.length) ? names : ['default'];
+ };
+
+ this.setEnvVars = function (vars) {
+ this.envVars = vars || null;
+ };
+
+ this.firstPreemptiveOption = function () {
+ let opts = this.opts;
+ for (let p in opts) {
+ if (preempts[p]) {
+ return preempts[p];
+ }
+ }
+ return false;
+ };
+
+ this.init = function (configuration) {
+ let self = this;
+ let config = configuration || {};
+ if (config.options) {
+ this.setOpts(config.options);
+ }
+ if (config.taskNames) {
+ this.setTaskNames(config.taskNames);
+ }
+ if (config.envVars) {
+ this.setEnvVars(config.envVars);
+ }
+ process.addListener('uncaughtException', function (err) {
+ self.handleErr(err);
+ });
+ if (!this.opts['allow-rejection']) {
+ process.addListener('unhandledRejection', (reason, promise) => {
+ utils.logger.error('Unhandled rejection at:', promise, 'reason:', reason);
+ self.handleErr(reason);
+ });
+ }
+ if (this.envVars) {
+ Object.assign(process.env, this.envVars);
+ }
+ };
+
+ this.run = function () {
+ let rootTask;
+ let taskNames;
+ let dirname;
+ let opts = this.opts;
+
+ if (opts.autocomplete) {
+ return this.autocompletions(opts['autocomplete-cur'], opts['autocomplete-prev']);
+ }
+ // Run with `jake -T`, just show descriptions
+ if (opts.tasks) {
+ return jake.showAllTaskDescriptions(opts.tasks);
+ }
+
+ taskNames = this.taskNames;
+ if (!(Array.isArray(taskNames) && taskNames.length)) {
+ throw new Error('Please pass jake.runTasks an array of task-names');
+ }
+
+ // Set working dir
+ dirname = opts.directory;
+ if (dirname) {
+ if (fs.existsSync(dirname) &&
+ fs.statSync(dirname).isDirectory()) {
+ process.chdir(dirname);
+ }
+ else {
+ throw new Error(dirname + ' is not a valid directory path');
+ }
+ }
+
+ rootTask = task(Task.ROOT_TASK_NAME, taskNames, function () {});
+ rootTask._internal = true;
+
+ rootTask.once('complete', function () {
+ jake.emit('complete');
+ });
+ jake.emit('start');
+ rootTask.invoke();
+ };
+
+})();
+
+module.exports.Program = Program;
diff --git a/tools/ui/node_modules/jake/lib/publish_task.js b/tools/ui/node_modules/jake/lib/publish_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..9aa8985ffab877dc827234f70aa2a8390846d4f0
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/publish_task.js
@@ -0,0 +1,290 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let fs = require('fs');
+let path = require('path');
+let exec = require('child_process').execSync;
+let FileList = require('filelist').FileList;
+
+let PublishTask = function () {
+ let args = Array.prototype.slice.call(arguments).filter(function (item) {
+ return typeof item != 'undefined';
+ });
+ let arg;
+ let opts = {};
+ let definition;
+ let prereqs = [];
+ let createDef = function (arg) {
+ return function () {
+ this.packageFiles.include(arg);
+ };
+ };
+
+ this.name = args.shift();
+
+ // Old API, just name + list of files
+ if (args.length == 1 && (Array.isArray(args[0]) || typeof args[0] == 'string')) {
+ definition = createDef(args.pop());
+ }
+ // Current API, name + [prereqs] + [opts] + definition
+ else {
+ while ((arg = args.pop())) {
+ // Definition func
+ if (typeof arg == 'function') {
+ definition = arg;
+ }
+ // Prereqs
+ else if (Array.isArray(arg) || typeof arg == 'string') {
+ prereqs = arg;
+ }
+ // Opts
+ else {
+ opts = arg;
+ }
+ }
+ }
+
+ this.prereqs = prereqs;
+ this.packageFiles = new FileList();
+ this.publishCmd = opts.publishCmd || 'npm publish %filename';
+ this.publishMessage = opts.publishMessage || 'BOOM! Published.';
+ this.gitCmd = opts.gitCmd || 'git';
+ this.versionFiles = opts.versionFiles || ['package.json'];
+ this.scheduleDelay = 5000;
+
+ // Override utility funcs for testing
+ this._ensureRepoClean = function (stdout) {
+ if (stdout.length) {
+ fail(new Error('Git repository is not clean.'));
+ }
+ };
+ this._getCurrentBranch = function (stdout) {
+ return String(stdout).trim();
+ };
+
+ if (typeof definition == 'function') {
+ definition.call(this);
+ }
+ this.define();
+};
+
+
+PublishTask.prototype = new (function () {
+
+ let _currentBranch = null;
+
+ let getPackage = function () {
+ let pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(),
+ '/package.json')).toString());
+ return pkg;
+ };
+ let getPackageVersionNumber = function () {
+ return getPackage().version;
+ };
+
+ this.define = function () {
+ let self = this;
+
+ namespace('publish', function () {
+ task('fetchTags', function () {
+ // Make sure local tags are up to date
+ exec(self.gitCmd + ' fetch --tags');
+ console.log('Fetched remote tags.');
+ });
+
+ task('getCurrentBranch', function () {
+ // Figure out what branch to push to
+ let stdout = exec(self.gitCmd + ' symbolic-ref --short HEAD').toString();
+ if (!stdout) {
+ throw new Error('No current Git branch found');
+ }
+ _currentBranch = self._getCurrentBranch(stdout);
+ console.log('On branch ' + _currentBranch);
+ });
+
+ task('ensureClean', function () {
+ // Only bump, push, and tag if the Git repo is clean
+ let stdout = exec(self.gitCmd + ' status --porcelain --untracked-files=no').toString();
+ // Throw if there's output
+ self._ensureRepoClean(stdout);
+ });
+
+ task('updateVersionFiles', function () {
+ let pkg;
+ let version;
+ let arr;
+ let patch;
+
+ // Grab the current version-string
+ pkg = getPackage();
+ version = pkg.version;
+ // Increment the patch-number for the version
+ arr = version.split('.');
+ patch = parseInt(arr.pop(), 10) + 1;
+ arr.push(patch);
+ version = arr.join('.');
+
+ // Update package.json or other files with the new version-info
+ self.versionFiles.forEach(function (file) {
+ let p = path.join(process.cwd(), file);
+ let data = JSON.parse(fs.readFileSync(p).toString());
+ data.version = version;
+ fs.writeFileSync(p, JSON.stringify(data, true, 2) + '\n');
+ });
+ // Return the version string so that listeners for the 'complete' event
+ // for this task can use it (e.g., to update other files before pushing
+ // to Git)
+ return version;
+ });
+
+ task('pushVersion', ['ensureClean', 'updateVersionFiles'], function () {
+ let version = getPackageVersionNumber();
+ let message = 'Version ' + version;
+ let cmds = [
+ self.gitCmd + ' commit -a -m "' + message + '"',
+ self.gitCmd + ' push origin ' + _currentBranch,
+ self.gitCmd + ' tag -a v' + version + ' -m "' + message + '"',
+ self.gitCmd + ' push --tags'
+ ];
+ cmds.forEach((cmd) => {
+ exec(cmd);
+ });
+ version = getPackageVersionNumber();
+ console.log('Bumped version number to v' + version + '.');
+ });
+
+ let defineTask = task('definePackage', function () {
+ let version = getPackageVersionNumber();
+ new jake.PackageTask(self.name, 'v' + version, self.prereqs, function () {
+ // Replace the PackageTask's FileList with the PublishTask's FileList
+ this.packageFiles = self.packageFiles;
+ this.needTarGz = true; // Default to tar.gz
+ // If any of the need or archive opts are set
+ // proxy them to the PackageTask
+ for (let p in this) {
+ if (p.indexOf('need') === 0 || p.indexOf('archive') === 0) {
+ if (typeof self[p] != 'undefined') {
+ this[p] = self[p];
+ }
+ }
+ }
+ });
+ });
+ defineTask._internal = true;
+
+ task('package', function () {
+ let definePack = jake.Task['publish:definePackage'];
+ let pack = jake.Task['package'];
+ let version = getPackageVersionNumber();
+
+ // May have already been run
+ if (definePack.taskStatus == jake.Task.runStatuses.DONE) {
+ definePack.reenable(true);
+ }
+ definePack.execute();
+ definePack.on('complete', function () {
+ pack.invoke();
+ console.log('Created package for ' + self.name + ' v' + version);
+ });
+ });
+
+ task('publish', function () {
+ return new Promise((resolve) => {
+ let version = getPackageVersionNumber();
+ let filename;
+ let cmd;
+
+ console.log('Publishing ' + self.name + ' v' + version);
+
+ if (typeof self.createPublishCommand == 'function') {
+ cmd = self.createPublishCommand(version);
+ }
+ else {
+ filename = './pkg/' + self.name + '-v' + version + '.tar.gz';
+ cmd = self.publishCmd.replace(/%filename/gi, filename);
+ }
+
+ if (typeof cmd == 'function') {
+ cmd(function (err) {
+ if (err) {
+ throw err;
+ }
+ console.log(self.publishMessage);
+ resolve();
+ });
+ }
+ else {
+ // Hackity hack -- NPM publish sometimes returns errror like:
+ // Error sending version data\nnpm ERR!
+ // Error: forbidden 0.2.4 is modified, should match modified time
+ setTimeout(function () {
+ let stdout = exec(cmd).toString() || '';
+ stdout = stdout.trim();
+ if (stdout) {
+ console.log(stdout);
+ }
+ console.log(self.publishMessage);
+ resolve();
+ }, self.scheduleDelay);
+ }
+ });
+ });
+
+ task('cleanup', function () {
+ return new Promise((resolve) => {
+ let clobber = jake.Task.clobber;
+ clobber.reenable(true);
+ clobber.on('complete', function () {
+ console.log('Cleaned up package');
+ resolve();
+ });
+ clobber.invoke();
+ });
+ });
+
+ });
+
+ let prefixNs = function (item) {
+ return 'publish:' + item;
+ };
+
+ // Create aliases in the default namespace
+ desc('Create a new version and release.');
+ task('publish', self.prereqs.concat(['version', 'release']
+ .map(prefixNs)));
+
+ desc('Release the existing version.');
+ task('publishExisting', self.prereqs.concat(['release']
+ .map(prefixNs)));
+
+ task('version', ['fetchTags', 'getCurrentBranch', 'pushVersion']
+ .map(prefixNs));
+
+ task('release', ['package', 'publish', 'cleanup']
+ .map(prefixNs));
+
+ // Invoke proactively so there will be a callable 'package' task
+ // which can be used apart from 'publish'
+ jake.Task['publish:definePackage'].invoke();
+ };
+
+})();
+
+jake.PublishTask = PublishTask;
+exports.PublishTask = PublishTask;
+
diff --git a/tools/ui/node_modules/jake/lib/rule.js b/tools/ui/node_modules/jake/lib/rule.js
new file mode 100644
index 0000000000000000000000000000000000000000..25f51ae4b0abb3b2a7e2a7a6c769eef14b3a2c3b
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/rule.js
@@ -0,0 +1,311 @@
+let path = require('path');
+let fs = require('fs');
+let Task = require('./task/task').Task;
+
+// Split a task to two parts, name space and task name.
+// For example, given 'foo:bin/a%.c', return an object with
+// - 'ns' : foo
+// - 'name' : bin/a%.c
+function splitNs(task) {
+ let parts = task.split(':');
+ let name = parts.pop();
+ let ns = resolveNs(parts);
+ return {
+ 'name' : name,
+ 'ns' : ns
+ };
+}
+
+// Return the namespace based on an array of names.
+// For example, given ['foo', 'baz' ], return the namespace
+//
+// default -> foo -> baz
+//
+// where default is the global root namespace
+// and -> means child namespace.
+function resolveNs(parts) {
+ let ns = jake.defaultNamespace;
+ for(let i = 0, l = parts.length; ns && i < l; i++) {
+ ns = ns.childNamespaces[parts[i]];
+ }
+ return ns;
+}
+
+// Given a pattern p, say 'foo:bin/a%.c'
+// Return an object with
+// - 'ns' : foo
+// - 'dir' : bin
+// - 'prefix' : a
+// - 'suffix' : .c
+function resolve(p) {
+ let task = splitNs(p);
+ let name = task.name;
+ let ns = task.ns;
+ let split = path.basename(name).split('%');
+ return {
+ ns: ns,
+ dir: path.dirname(name),
+ prefix: split[0],
+ suffix: split[1]
+ };
+}
+
+// Test whether string a is a suffix of string b
+function stringEndWith(a, b) {
+ let l;
+ return (l = b.lastIndexOf(a)) == -1 ? false : l + a.length == b.length;
+}
+
+// Replace the suffix a of the string s with b.
+// Note that, it is assumed a is a suffix of s.
+function stringReplaceSuffix(s, a, b) {
+ return s.slice(0, s.lastIndexOf(a)) + b;
+}
+
+class Rule {
+ constructor(opts) {
+ this.pattern = opts.pattern;
+ this.source = opts.source;
+ this.prereqs = opts.prereqs;
+ this.action = opts.action;
+ this.opts = opts.opts;
+ this.desc = opts.desc;
+ this.ns = opts.ns;
+ }
+
+ // Create a file task based on this rule for the specified
+ // task-name
+ // ======
+ // FIXME: Right now this just throws away any passed-in args
+ // for the synthsized task (taskArgs param)
+ // ======
+ createTask(fullName, level) {
+ let self = this;
+ let pattern;
+ let source;
+ let action;
+ let opts;
+ let prereqs;
+ let valid;
+ let src;
+ let tNs;
+ let createdTask;
+ let name = Task.getBaseTaskName(fullName);
+ let nsPath = Task.getBaseNamespacePath(fullName);
+ let ns = this.ns.resolveNamespace(nsPath);
+
+ pattern = this.pattern;
+ source = this.source;
+
+ if (typeof source == 'string') {
+ src = Rule.getSource(name, pattern, source);
+ }
+ else {
+ src = source(name);
+ }
+
+ // TODO: Write a utility function that appends a
+ // taskname to a namespace path
+ src = nsPath.split(':').filter(function (item) {
+ return !!item;
+ }).concat(src).join(':');
+
+ // Generate the prerequisite for the matching task.
+ // It is the original prerequisites plus the prerequisite
+ // representing source file, i.e.,
+ //
+ // rule( '%.o', '%.c', ['some.h'] ...
+ //
+ // If the objective is main.o, then new task should be
+ //
+ // file( 'main.o', ['main.c', 'some.h' ] ...
+ prereqs = this.prereqs.slice(); // Get a copy to work with
+ prereqs.unshift(src);
+
+ // Prereq should be:
+ // 1. an existing task
+ // 2. an existing file on disk
+ // 3. a valid rule (i.e., not at too deep a level)
+ valid = prereqs.some(function (p) {
+ let ns = self.ns;
+ return ns.resolveTask(p) ||
+ fs.existsSync(Task.getBaseTaskName(p)) ||
+ jake.attemptRule(p, ns, level + 1);
+ });
+
+ // If any of the prereqs aren't valid, the rule isn't valid
+ if (!valid) {
+ return null;
+ }
+ // Otherwise, hunky-dory, finish creating the task for the rule
+ else {
+ // Create the action for the task
+ action = function () {
+ let task = this;
+ self.action.apply(task);
+ };
+
+ opts = this.opts;
+
+ // Insert the file task into Jake
+ //
+ // Since createTask function stores the task as a child task
+ // of currentNamespace. Here we temporariliy switch the namespace.
+ // FIXME: Should allow optional ns passed in instead of this hack
+ tNs = jake.currentNamespace;
+ jake.currentNamespace = ns;
+ createdTask = jake.createTask('file', name, prereqs, action, opts);
+ createdTask.source = src.split(':').pop();
+ jake.currentNamespace = tNs;
+
+ return createdTask;
+ }
+ }
+
+ match(name) {
+ return Rule.match(this.pattern, name);
+ }
+
+ // Test wether the a prerequisite matchs the pattern.
+ // The arg 'pattern' does not have namespace as prefix.
+ // For example, the following tests are true
+ //
+ // pattern | name
+ // bin/%.o | bin/main.o
+ // bin/%.o | foo:bin/main.o
+ //
+ // The following tests are false (trivally)
+ //
+ // pattern | name
+ // bin/%.o | foobin/main.o
+ // bin/%.o | bin/main.oo
+ static match(pattern, name) {
+ let p;
+ let task;
+ let obj;
+ let filename;
+
+ if (pattern instanceof RegExp) {
+ return pattern.test(name);
+ }
+ else if (pattern.indexOf('%') == -1) {
+ // No Pattern. No Folder. No Namespace.
+ // A Simple Suffix Rule. Just test suffix
+ return stringEndWith(pattern, name);
+ }
+ else {
+ // Resolve the dir, prefix and suffix of pattern
+ p = resolve(pattern);
+
+ // Resolve the namespace and task-name
+ task = splitNs(name);
+ name = task.name;
+
+ // Set the objective as the task-name
+ obj = name;
+
+ // Namespace is already matched.
+
+ // Check dir
+ if (path.dirname(obj) != p.dir) {
+ return false;
+ }
+
+ filename = path.basename(obj);
+
+ // Check file name length
+ if ((p.prefix.length + p.suffix.length + 1) > filename.length) {
+ // Length does not match.
+ return false;
+ }
+
+ // Check prefix
+ if (filename.indexOf(p.prefix) !== 0) {
+ return false;
+ }
+
+ // Check suffix
+ if (!stringEndWith(p.suffix, filename)) {
+ return false;
+ }
+
+ // OK. Find a match.
+ return true;
+ }
+ }
+
+ // Generate the source based on
+ // - name name for the synthesized task
+ // - pattern pattern for the objective
+ // - source pattern for the source
+ //
+ // Return the source with properties
+ // - dep the prerequisite of source
+ // (with the namespace)
+ //
+ // - file the file name of source
+ // (without the namespace)
+ //
+ // For example, given
+ //
+ // - name foo:bin/main.o
+ // - pattern bin/%.o
+ // - source src/%.c
+ //
+ // return 'foo:src/main.c',
+ //
+ static getSource(name, pattern, source) {
+ let dep;
+ let pat;
+ let match;
+ let file;
+ let src;
+
+ // Regex pattern -- use to look up the extension
+ if (pattern instanceof RegExp) {
+ match = pattern.exec(name);
+ if (match) {
+ if (typeof source == 'function') {
+ src = source(name);
+ }
+ else {
+ src = stringReplaceSuffix(name, match[0], source);
+ }
+ }
+ }
+ // Assume string
+ else {
+ // Simple string suffix replacement
+ if (pattern.indexOf('%') == -1) {
+ if (typeof source == 'function') {
+ src = source(name);
+ }
+ else {
+ src = stringReplaceSuffix(name, pattern, source);
+ }
+ }
+ // Percent-based substitution
+ else {
+ pat = pattern.replace('%', '(.*?)');
+ pat = new RegExp(pat);
+ match = pat.exec(name);
+ if (match) {
+ if (typeof source == 'function') {
+ src = source(name);
+ }
+ else {
+ file = match[1];
+ file = source.replace('%', file);
+ dep = match[0];
+ src = name.replace(dep, file);
+ }
+ }
+ }
+ }
+
+ return src;
+ }
+}
+
+
+exports.Rule = Rule;
diff --git a/tools/ui/node_modules/jake/lib/task/directory_task.js b/tools/ui/node_modules/jake/lib/task/directory_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..b17b62466881f784cb6150a05cbec3cfd4768c7b
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/task/directory_task.js
@@ -0,0 +1,30 @@
+let fs = require('fs');
+let FileTask = require('./file_task').FileTask;
+
+/**
+ @name jake
+ @namespace jake
+*/
+/**
+ @name jake.DirectoryTask
+ @constructor
+ @augments EventEmitter
+ @augments jake.Task
+ @augments jake.FileTask
+ @description A Jake DirectoryTask
+
+ @param {String} name The name of the directory to create.
+ */
+class DirectoryTask extends FileTask {
+ constructor(...args) {
+ super(...args);
+ if (fs.existsSync(this.name)) {
+ this.updateModTime();
+ }
+ else {
+ this.modTime = null;
+ }
+ }
+}
+
+exports.DirectoryTask = DirectoryTask;
diff --git a/tools/ui/node_modules/jake/lib/task/file_task.js b/tools/ui/node_modules/jake/lib/task/file_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..d23aba8775060afb333c7d07b5398ead1cafb3ae
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/task/file_task.js
@@ -0,0 +1,126 @@
+let fs = require('fs');
+let Task = require('./task').Task;
+
+function isFileOrDirectory(t) {
+ return (t instanceof FileTask ||
+ t instanceof DirectoryTask);
+}
+
+function isFile(t) {
+ return (t instanceof FileTask && !(t instanceof DirectoryTask));
+}
+
+/**
+ @name jake
+ @namespace jake
+*/
+/**
+ @name jake.FileTask
+ @class`
+ @extentds Task
+ @description A Jake FileTask
+
+ @param {String} name The name of the Task
+ @param {Array} [prereqs] Prerequisites to be run before this task
+ @param {Function} [action] The action to perform to create this file
+ @param {Object} [opts]
+ @param {Array} [opts.asyc=false] Perform this task asynchronously.
+ If you flag a task with this option, you must call the global
+ `complete` method inside the task's action, for execution to proceed
+ to the next task.
+ */
+class FileTask extends Task {
+ constructor(...args) {
+ super(...args);
+ this.dummy = false;
+ if (fs.existsSync(this.name)) {
+ this.updateModTime();
+ }
+ else {
+ this.modTime = null;
+ }
+ }
+
+ isNeeded() {
+ let prereqs = this.prereqs;
+ let prereqName;
+ let prereqTask;
+
+ // No repeatsies
+ if (this.taskStatus == Task.runStatuses.DONE) {
+ return false;
+ }
+ // The always-make override
+ else if (jake.program.opts['always-make']) {
+ return true;
+ }
+ // Default case
+ else {
+
+ // We need either an existing file, or an action to create one.
+ // First try grabbing the actual mod-time of the file
+ try {
+ this.updateModTime();
+ }
+ // Then fall back to looking for an action
+ catch(e) {
+ if (typeof this.action == 'function') {
+ return true;
+ }
+ else {
+ throw new Error('File-task ' + this.fullName + ' has no ' +
+ 'existing file, and no action to create one.');
+ }
+ }
+
+ // Compare mod-time of all the prereqs with its mod-time
+ // If any prereqs are newer, need to run the action to update
+ if (prereqs && prereqs.length) {
+ for (let i = 0, ii = prereqs.length; i < ii; i++) {
+ prereqName = prereqs[i];
+ prereqTask = this.namespace.resolveTask(prereqName) ||
+ jake.createPlaceholderFileTask(prereqName, this.namespace);
+ // Run the action if:
+ // 1. The prereq is a normal task (not file/dir)
+ // 2. The prereq is a file-task with a mod-date more recent than
+ // the one for this file/dir
+ if (prereqTask) {
+ if (!isFileOrDirectory(prereqTask) ||
+ (isFile(prereqTask) && prereqTask.modTime > this.modTime)) {
+ return true;
+ }
+ }
+ }
+ this.taskStatus = Task.runStatuses.DONE;
+ return false;
+ }
+ // File/dir has no prereqs, and exists -- no need to run
+ else {
+ // Effectively done
+ this.taskStatus = Task.runStatuses.DONE;
+ return false;
+ }
+ }
+ }
+
+ updateModTime() {
+ let stats = fs.statSync(this.name);
+ this.modTime = stats.mtime;
+ }
+
+ complete() {
+ if (!this.dummy) {
+ this.updateModTime();
+ }
+ // Hackity hack
+ Task.prototype.complete.apply(this, arguments);
+ }
+
+}
+
+exports.FileTask = FileTask;
+
+// DirectoryTask is a subclass of FileTask, depends on it
+// being defined
+let DirectoryTask = require('./directory_task').DirectoryTask;
+
diff --git a/tools/ui/node_modules/jake/lib/task/index.js b/tools/ui/node_modules/jake/lib/task/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc93f4147386137b4002fe406d3ed5e35b22f3bc
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/task/index.js
@@ -0,0 +1,9 @@
+
+let Task = require('./task').Task;
+let FileTask = require('./file_task').FileTask;
+let DirectoryTask = require('./directory_task').DirectoryTask;
+
+exports.Task = Task;
+exports.FileTask = FileTask;
+exports.DirectoryTask = DirectoryTask;
+
diff --git a/tools/ui/node_modules/jake/lib/task/task.js b/tools/ui/node_modules/jake/lib/task/task.js
new file mode 100644
index 0000000000000000000000000000000000000000..7833b5090ab85a839c8dd43222cc8f3a8bab3e5f
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/task/task.js
@@ -0,0 +1,458 @@
+let EventEmitter = require('events').EventEmitter;
+let async = require('async');
+let pc = require('picocolors');
+// 'rule' module is required at the bottom because circular deps
+
+// Used for task value, so better not to use
+// null, since value should be unset/uninitialized
+let UNDEFINED_VALUE;
+
+const ROOT_TASK_NAME = '__rootTask__';
+const POLLING_INTERVAL = 100;
+
+// Parse any positional args attached to the task-name
+function parsePrereqName(name) {
+ let taskArr = name.split('[');
+ let taskName = taskArr[0];
+ let taskArgs = [];
+ if (taskArr[1]) {
+ taskArgs = taskArr[1].replace(/\]$/, '');
+ taskArgs = taskArgs.split(',');
+ }
+ return {
+ name: taskName,
+ args: taskArgs
+ };
+}
+
+/**
+ @name jake.Task
+ @class
+ @extends EventEmitter
+ @description A Jake Task
+
+ @param {String} name The name of the Task
+ @param {Array} [prereqs] Prerequisites to be run before this task
+ @param {Function} [action] The action to perform for this task
+ @param {Object} [opts]
+ @param {Array} [opts.asyc=false] Perform this task asynchronously.
+ If you flag a task with this option, you must call the global
+ `complete` method inside the task's action, for execution to proceed
+ to the next task.
+ */
+class Task extends EventEmitter {
+
+ constructor(name, prereqs, action, options) {
+ // EventEmitter ctor takes no args
+ super();
+
+ if (name.indexOf(':') > -1) {
+ throw new Error('Task name cannot include a colon. It is used internally as namespace delimiter.');
+ }
+ let opts = options || {};
+
+ this._currentPrereqIndex = 0;
+ this._internal = false;
+ this._skipped = false;
+
+ this.name = name;
+ this.prereqs = prereqs;
+ this.action = action;
+ this.async = false;
+ this.taskStatus = Task.runStatuses.UNSTARTED;
+ this.description = null;
+ this.args = [];
+ this.value = UNDEFINED_VALUE;
+ this.concurrency = 1;
+ this.startTime = null;
+ this.endTime = null;
+ this.directory = null;
+ this.namespace = null;
+
+ // Support legacy async-flag -- if not explicitly passed or falsy, will
+ // be set to empty-object
+ if (typeof opts == 'boolean' && opts === true) {
+ this.async = true;
+ }
+ else {
+ if (opts.async) {
+ this.async = true;
+ }
+ if (opts.concurrency) {
+ this.concurrency = opts.concurrency;
+ }
+ }
+
+ //Do a test on self dependencies for this task
+ if(Array.isArray(this.prereqs) && this.prereqs.indexOf(this.name) !== -1) {
+ throw new Error("Cannot use prereq " + this.name + " as a dependency of itself");
+ }
+ }
+
+ get fullName() {
+ return this._getFullName();
+ }
+
+ get params() {
+ return this._getParams();
+ }
+
+ _initInvocationChain() {
+ // Legacy global invocation chain
+ jake._invocationChain.push(this);
+
+ // New root chain
+ if (!this._invocationChain) {
+ this._invocationChainRoot = true;
+ this._invocationChain = [];
+ if (jake.currentRunningTask) {
+ jake.currentRunningTask._waitForChains = jake.currentRunningTask._waitForChains || [];
+ jake.currentRunningTask._waitForChains.push(this._invocationChain);
+ }
+ }
+ }
+
+ /**
+ @name jake.Task#invoke
+ @function
+ @description Runs prerequisites, then this task. If the task has already
+ been run, will not run the task again.
+ */
+ invoke() {
+ this._initInvocationChain();
+
+ this.args = Array.prototype.slice.call(arguments);
+ this.reenabled = false;
+ this.runPrereqs();
+ }
+
+ /**
+ @name jake.Task#execute
+ @function
+ @description Run only this task, without prereqs. If the task has already
+ been run, *will* run the task again.
+ */
+ execute() {
+ this._initInvocationChain();
+
+ this.args = Array.prototype.slice.call(arguments);
+ this.reenable();
+ this.reenabled = true;
+ this.run();
+ }
+
+ runPrereqs() {
+ if (this.prereqs && this.prereqs.length) {
+
+ if (this.concurrency > 1) {
+ async.eachLimit(this.prereqs, this.concurrency,
+
+ (name, cb) => {
+ let parsed = parsePrereqName(name);
+
+ let prereq = this.namespace.resolveTask(parsed.name) ||
+ jake.attemptRule(name, this.namespace, 0) ||
+ jake.createPlaceholderFileTask(name, this.namespace);
+
+ if (!prereq) {
+ throw new Error('Unknown task "' + name + '"');
+ }
+
+ //Test for circular invocation
+ if(prereq === this) {
+ setImmediate(function () {
+ cb(new Error("Cannot use prereq " + prereq.name + " as a dependency of itself"));
+ });
+ }
+
+ if (prereq.taskStatus == Task.runStatuses.DONE) {
+ //prereq already done, return
+ setImmediate(cb);
+ }
+ else {
+ //wait for complete before calling cb
+ prereq.once('_done', () => {
+ prereq.removeAllListeners('_done');
+ setImmediate(cb);
+ });
+ // Start the prereq if we are the first to encounter it
+ if (prereq.taskStatus === Task.runStatuses.UNSTARTED) {
+ prereq.taskStatus = Task.runStatuses.STARTED;
+ prereq.invoke.apply(prereq, parsed.args);
+ }
+ }
+ },
+
+ (err) => {
+ //async callback is called after all prereqs have run.
+ if (err) {
+ throw err;
+ }
+ else {
+ setImmediate(this.run.bind(this));
+ }
+ }
+ );
+ }
+ else {
+ setImmediate(this.nextPrereq.bind(this));
+ }
+ }
+ else {
+ setImmediate(this.run.bind(this));
+ }
+ }
+
+ nextPrereq() {
+ let self = this;
+ let index = this._currentPrereqIndex;
+ let name = this.prereqs[index];
+ let prereq;
+ let parsed;
+
+ if (name) {
+
+ parsed = parsePrereqName(name);
+
+ prereq = this.namespace.resolveTask(parsed.name) ||
+ jake.attemptRule(name, this.namespace, 0) ||
+ jake.createPlaceholderFileTask(name, this.namespace);
+
+ if (!prereq) {
+ throw new Error('Unknown task "' + name + '"');
+ }
+
+ // Do when done
+ if (prereq.taskStatus == Task.runStatuses.DONE) {
+ self.handlePrereqDone(prereq);
+ }
+ else {
+ prereq.once('_done', () => {
+ this.handlePrereqDone(prereq);
+ prereq.removeAllListeners('_done');
+ });
+ if (prereq.taskStatus == Task.runStatuses.UNSTARTED) {
+ prereq.taskStatus = Task.runStatuses.STARTED;
+ prereq._invocationChain = this._invocationChain;
+ prereq.invoke.apply(prereq, parsed.args);
+ }
+ }
+ }
+ }
+
+ /**
+ @name jake.Task#reenable
+ @function
+ @description Reenables a task so that it can be run again.
+ */
+ reenable(deep) {
+ let prereqs;
+ let prereq;
+ this._skipped = false;
+ this.taskStatus = Task.runStatuses.UNSTARTED;
+ this.value = UNDEFINED_VALUE;
+ if (deep && this.prereqs) {
+ prereqs = this.prereqs;
+ for (let i = 0, ii = prereqs.length; i < ii; i++) {
+ prereq = jake.Task[prereqs[i]];
+ if (prereq) {
+ prereq.reenable(deep);
+ }
+ }
+ }
+ }
+
+ handlePrereqDone(prereq) {
+ this._currentPrereqIndex++;
+ if (this._currentPrereqIndex < this.prereqs.length) {
+ setImmediate(this.nextPrereq.bind(this));
+ }
+ else {
+ setImmediate(this.run.bind(this));
+ }
+ }
+
+ isNeeded() {
+ let needed = true;
+ if (this.taskStatus == Task.runStatuses.DONE) {
+ needed = false;
+ }
+ return needed;
+ }
+
+ run() {
+ let val, previous;
+ let hasAction = typeof this.action == 'function';
+
+ if (!this.isNeeded()) {
+ this.emit('skip');
+ this.emit('_done');
+ }
+ else {
+ if (this._invocationChain.length) {
+ previous = this._invocationChain[this._invocationChain.length - 1];
+ // If this task is repeating and its previous is equal to this, don't check its status because it was set to UNSTARTED by the reenable() method
+ if (!(this.reenabled && previous == this)) {
+ if (previous.taskStatus != Task.runStatuses.DONE) {
+ let now = (new Date()).getTime();
+ if (now - this.startTime > jake._taskTimeout) {
+ return jake.fail(`Timed out waiting for task: ${previous.name} with status of ${previous.taskStatus}`);
+ }
+ setTimeout(this.run.bind(this), POLLING_INTERVAL);
+ return;
+ }
+ }
+ }
+ if (!(this.reenabled && previous == this)) {
+ this._invocationChain.push(this);
+ }
+
+ if (!(this._internal || jake.program.opts.quiet)) {
+ jake.emit('started', {
+ name: this.fullName,
+ task: this,
+ });
+ console.log("Starting '" + pc.green(this.fullName) + "'...");
+ }
+
+ this.startTime = (new Date()).getTime();
+ this.emit('start');
+
+ jake.currentRunningTask = this;
+
+ if (hasAction) {
+ try {
+ if (this.directory) {
+ process.chdir(this.directory);
+ }
+
+ val = this.action.apply(this, this.args);
+
+ if (typeof val == 'object' && typeof val.then == 'function') {
+ this.async = true;
+
+ val.then(
+ (result) => {
+ setImmediate(() => {
+ this.complete(result);
+ });
+ },
+ (err) => {
+ setImmediate(() => {
+ this.errorOut(err);
+ });
+ });
+ }
+ }
+ catch (err) {
+ this.errorOut(err);
+ return; // Bail out, not complete
+ }
+ }
+
+ if (!(hasAction && this.async)) {
+ setImmediate(() => {
+ this.complete(val);
+ });
+ }
+ }
+ }
+
+ errorOut(err) {
+ this.taskStatus = Task.runStatuses.ERROR;
+ this._invocationChain.chainStatus = Task.runStatuses.ERROR;
+ this.emit('error', err);
+ }
+
+ complete(val) {
+
+ if (Array.isArray(this._waitForChains)) {
+ let stillWaiting = this._waitForChains.some((chain) => {
+ return !(chain.chainStatus == Task.runStatuses.DONE ||
+ chain.chainStatus == Task.runStatuses.ERROR);
+ });
+ if (stillWaiting) {
+ let now = (new Date()).getTime();
+ let elapsed = now - this.startTime;
+ if (elapsed > jake._taskTimeout) {
+ return jake.fail(`Timed out waiting for task: ${this.name} with status of ${this.taskStatus}. Elapsed: ${elapsed}`);
+ }
+ setTimeout(() => {
+ this.complete(val);
+ }, POLLING_INTERVAL);
+ return;
+ }
+ }
+
+ jake._invocationChain.splice(jake._invocationChain.indexOf(this), 1);
+
+ if (this._invocationChainRoot) {
+ this._invocationChain.chainStatus = Task.runStatuses.DONE;
+ }
+
+ this._currentPrereqIndex = 0;
+
+ // If 'complete' getting called because task has been
+ // run already, value will not be passed -- leave in place
+ if (!this._skipped) {
+ this.taskStatus = Task.runStatuses.DONE;
+ this.value = val;
+
+ this.emit('complete', this.value);
+ this.emit('_done');
+
+ this.endTime = (new Date()).getTime();
+ let taskTime = this.endTime - this.startTime;
+
+ if (!(this._internal || jake.program.opts.quiet)) {
+ jake.emit('finished', {
+ name: this.fullName,
+ task: this,
+ time: taskTime,
+ });
+ console.log("Finished '" + pc.green(this.fullName) + "' after " + pc.magenta(taskTime + ' ms'));
+ }
+
+ }
+ }
+
+ _getFullName() {
+ let ns = this.namespace;
+ let path = (ns && ns.path) || '';
+ path = (path && path.split(':')) || [];
+ if (this.namespace !== jake.defaultNamespace) {
+ path.push(this.namespace.name);
+ }
+ path.push(this.name);
+ return path.join(':');
+ }
+
+ _getParams() {
+ if (!this.action) return "";
+ let params = (new RegExp('(?:'+this.action.name+'\\s*|^)\\s*\\((.*?)\\)').exec(this.action.toString().replace(/\n/g, '')) || [''])[1].replace(/\/\*.*?\*\//g, '').replace(/ /g, '');
+ return params;
+ }
+
+ static getBaseNamespacePath(fullName) {
+ return fullName.split(':').slice(0, -1).join(':');
+ }
+
+ static getBaseTaskName(fullName) {
+ return fullName.split(':').pop();
+ }
+}
+
+Task.runStatuses = {
+ UNSTARTED: 'unstarted',
+ DONE: 'done',
+ STARTED: 'started',
+ ERROR: 'error'
+};
+
+Task.ROOT_TASK_NAME = ROOT_TASK_NAME;
+
+exports.Task = Task;
+
+// Required here because circular deps
+require('../rule');
+
diff --git a/tools/ui/node_modules/jake/lib/test_task.js b/tools/ui/node_modules/jake/lib/test_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..6482bf14d6980779b89b191e5b0d051904dd3dd7
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/test_task.js
@@ -0,0 +1,270 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let path = require('path');
+let currDir = process.cwd();
+
+/**
+ @name jake
+ @namespace jake
+*/
+/**
+ @name jake.TestTask
+ @constructor
+ @description Instantiating a TestTask creates a number of Jake
+ Tasks that make running tests for your software easy.
+
+ @param {String} name The name of the project
+ @param {Function} definition Defines the list of files containing the tests,
+ and the name of the namespace/task for running them. Will be executed on the
+ instantiated TestTask (i.e., 'this', will be the TestTask instance), to set
+ the various instance-propertiess.
+
+ @example
+ let t = new jake.TestTask('bij-js', function () {
+ this.testName = 'testSpecial';
+ this.testFiles.include('test/**');
+ });
+
+ */
+let TestTask = function () {
+ let self = this;
+ let args = Array.prototype.slice.call(arguments);
+ let name = args.shift();
+ let definition = args.pop();
+ let prereqs = args.pop() || [];
+
+ /**
+ @name jake.TestTask#testNam
+ @public
+ @type {String}
+ @description The name of the namespace to place the tests in, and
+ the top-level task for running tests. Defaults to "test"
+ */
+ this.testName = 'test';
+
+ /**
+ @name jake.TestTask#testFiles
+ @public
+ @type {jake.FileList}
+ @description The list of files containing tests to load
+ */
+ this.testFiles = new jake.FileList();
+
+ /**
+ @name jake.TestTask#showDescription
+ @public
+ @type {Boolean}
+ @description Show the created task when doing Jake -T
+ */
+ this.showDescription = true;
+
+ /*
+ @name jake.TestTask#totalTests
+ @public
+ @type {Number}
+ @description The total number of tests to run
+ */
+ this.totalTests = 0;
+
+ /*
+ @name jake.TestTask#executedTests
+ @public
+ @type {Number}
+ @description The number of tests successfully run
+ */
+ this.executedTests = 0;
+
+ if (typeof definition == 'function') {
+ definition.call(this);
+ }
+
+ if (this.showDescription) {
+ desc('Run the tests for ' + name);
+ }
+
+ task(this.testName, prereqs, {async: true}, function () {
+ let t = jake.Task[this.fullName + ':run'];
+ t.on('complete', function () {
+ complete();
+ });
+ // Pass args to the namespaced test
+ t.invoke.apply(t, arguments);
+ });
+
+ namespace(self.testName, function () {
+
+ let runTask = task('run', {async: true}, function (pat) {
+ let re;
+ let testFiles;
+
+ // Don't nest; make a top-level namespace. Don't want
+ // re-calling from inside to nest infinitely
+ jake.currentNamespace = jake.defaultNamespace;
+
+ re = new RegExp(pat);
+ // Get test files that match the passed-in pattern
+ testFiles = self.testFiles.toArray()
+ .filter(function (f) {
+ return (re).test(f);
+ }) // Don't load the same file multiple times -- should this be in FileList?
+ .reduce(function (p, c) {
+ if (p.indexOf(c) < 0) {
+ p.push(c);
+ }
+ return p;
+ }, []);
+
+ // Create a namespace for all the testing tasks to live in
+ namespace(self.testName + 'Exec', function () {
+ // Each test will be a prereq for the dummy top-level task
+ let prereqs = [];
+ // Continuation to pass to the async tests, wrapping `continune`
+ let next = function () {
+ complete();
+ };
+ // Create the task for this test-function
+ let createTask = function (name, action) {
+ // If the test-function is defined with a continuation
+ // param, flag the task as async
+ let t;
+ let isAsync = !!action.length;
+
+ // Define the actual namespaced task with the name, the
+ // wrapped action, and the correc async-flag
+ t = task(name, createAction(name, action), {
+ async: isAsync
+ });
+ t.once('complete', function () {
+ self.executedTests++;
+ });
+ t._internal = true;
+ return t;
+ };
+ // Used as the action for the defined task for each test.
+ let createAction = function (n, a) {
+ // A wrapped function that passes in the `next` function
+ // for any tasks that run asynchronously
+ return function () {
+ let cb;
+ if (a.length) {
+ cb = next;
+ }
+ if (!(n == 'before' || n == 'after' ||
+ /_beforeEach$/.test(n) || /_afterEach$/.test(n))) {
+ jake.logger.log(n);
+ }
+ // 'this' will be the task when action is run
+ return a.call(this, cb);
+ };
+ };
+ // Dummy top-level task for everything to be prereqs for
+ let topLevel;
+
+ // Pull in each test-file, and iterate over any exported
+ // test-functions. Register each test-function as a prereq task
+ testFiles.forEach(function (file) {
+ let exp = require(path.join(currDir, file));
+
+ // Create a namespace for each filename, so test-name collisions
+ // won't be a problem
+ namespace(file, function () {
+ let testPrefix = self.testName + 'Exec:' + file + ':';
+ let testName;
+ // Dummy task for displaying file banner
+ testName = '*** Running ' + file + ' ***';
+ prereqs.push(testPrefix + testName);
+ createTask(testName, function () {});
+
+ // 'before' setup
+ if (typeof exp.before == 'function') {
+ prereqs.push(testPrefix + 'before');
+ // Create the task
+ createTask('before', exp.before);
+ }
+
+ // Walk each exported function, and create a task for each
+ for (let p in exp) {
+ if (p == 'before' || p == 'after' ||
+ p == 'beforeEach' || p == 'afterEach') {
+ continue;
+ }
+
+ if (typeof exp.beforeEach == 'function') {
+ prereqs.push(testPrefix + p + '_beforeEach');
+ // Create the task
+ createTask(p + '_beforeEach', exp.beforeEach);
+ }
+
+ // Add the namespace:name of this test to the list of prereqs
+ // for the dummy top-level task
+ prereqs.push(testPrefix + p);
+ // Create the task
+ createTask(p, exp[p]);
+
+ if (typeof exp.afterEach == 'function') {
+ prereqs.push(testPrefix + p + '_afterEach');
+ // Create the task
+ createTask(p + '_afterEach', exp.afterEach);
+ }
+ }
+
+ // 'after' teardown
+ if (typeof exp.after == 'function') {
+ prereqs.push(testPrefix + 'after');
+ // Create the task
+ let afterTask = createTask('after', exp.after);
+ afterTask._internal = true;
+ }
+
+ });
+ });
+
+ self.totalTests = prereqs.length;
+ process.on('exit', function () {
+ // Throw in the case where the process exits without
+ // finishing tests, but no error was thrown
+ if (!jake.errorCode && (self.totalTests > self.executedTests)) {
+ throw new Error('Process exited without all tests completing.');
+ }
+ });
+
+ // Create the dummy top-level task. When calling a task internally
+ // with `invoke` that is async (or has async prereqs), have to listen
+ // for the 'complete' event to know when it's done
+ topLevel = task('__top__', prereqs);
+ topLevel._internal = true;
+ topLevel.addListener('complete', function () {
+ jake.logger.log('All tests ran successfully');
+ complete();
+ });
+
+ topLevel.invoke(); // Do the thing!
+ });
+
+ });
+ runTask._internal = true;
+
+ });
+
+
+};
+
+jake.TestTask = TestTask;
+exports.TestTask = TestTask;
+
diff --git a/tools/ui/node_modules/jake/lib/utils/file.js b/tools/ui/node_modules/jake/lib/utils/file.js
new file mode 100644
index 0000000000000000000000000000000000000000..d7163f30938202473fd3dbc7e290286baaa57f81
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/utils/file.js
@@ -0,0 +1,286 @@
+/*
+ * Utilities: A classic collection of JavaScript utilities
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+let fs = require('fs');
+let path = require('path');
+
+/**
+ @name file
+ @namespace file
+*/
+
+let fileUtils = new (function () {
+
+ // Recursively copy files and directories
+ let _copyFile = function (fromPath, toPath, opts) {
+ let from = path.normalize(fromPath);
+ let to = path.normalize(toPath);
+ let options = opts || {};
+ let fromStat;
+ let toStat;
+ let destExists;
+ let destDoesNotExistErr;
+ let content;
+ let filename;
+ let dirContents;
+ let targetDir;
+
+ fromStat = fs.statSync(from);
+
+ try {
+ //console.dir(to + ' destExists');
+ toStat = fs.statSync(to);
+ destExists = true;
+ }
+ catch(e) {
+ //console.dir(to + ' does not exist');
+ destDoesNotExistErr = e;
+ destExists = false;
+ }
+ // Destination dir or file exists, copy into (directory)
+ // or overwrite (file)
+ if (destExists) {
+
+ // If there's a rename-via-copy file/dir name passed, use it.
+ // Otherwise use the actual file/dir name
+ filename = options.rename || path.basename(from);
+
+ // Copying a directory
+ if (fromStat.isDirectory()) {
+ dirContents = fs.readdirSync(from);
+ targetDir = path.join(to, filename);
+ // We don't care if the target dir already exists
+ try {
+ fs.mkdirSync(targetDir, {mode: fromStat.mode & 0o777});
+ }
+ catch(e) {
+ if (e.code !== 'EEXIST') {
+ throw e;
+ }
+ }
+ for (let i = 0, ii = dirContents.length; i < ii; i++) {
+ _copyFile(path.join(from, dirContents[i]), targetDir, {preserveMode: options.preserveMode});
+ }
+ }
+ // Copying a file
+ else {
+ content = fs.readFileSync(from);
+ let mode = fromStat.mode & 0o777;
+ let targetFile = to;
+
+ if (toStat.isDirectory()) {
+ targetFile = path.join(to, filename);
+ }
+
+ let fileExists = fs.existsSync(targetFile);
+ fs.writeFileSync(targetFile, content);
+
+ // If the file didn't already exist, use the original file mode.
+ // Otherwise, only update the mode if preserverMode is true.
+ if(!fileExists || options.preserveMode) {
+ fs.chmodSync(targetFile, mode);
+ }
+ }
+ }
+ // Dest doesn't exist, can't create it
+ else {
+ throw destDoesNotExistErr;
+ }
+ };
+
+ // Remove the given directory
+ let _rmDir = function (dirPath) {
+ let dir = path.normalize(dirPath);
+ let paths = [];
+ paths = fs.readdirSync(dir);
+ paths.forEach(function (p) {
+ let curr = path.join(dir, p);
+ let stat = fs.lstatSync(curr);
+ if (stat.isDirectory()) {
+ _rmDir(curr);
+ }
+ else {
+ try {
+ fs.unlinkSync(curr);
+ } catch(e) {
+ if (e.code === 'EPERM') {
+ fs.chmodSync(curr, parseInt(666, 8));
+ fs.unlinkSync(curr);
+ } else {
+ throw e;
+ }
+ }
+ }
+ });
+ fs.rmdirSync(dir);
+ };
+
+ /**
+ @name file#cpR
+ @public
+ @function
+ @description Copies a directory/file to a destination
+ @param {String} fromPath The source path to copy from
+ @param {String} toPath The destination path to copy to
+ @param {Object} opts Options to use
+ @param {Boolean} [opts.preserveMode] If target file already exists, this
+ determines whether the original file's mode is copied over. The default of
+ false mimics the behavior of the `cp` command line tool. (Default: false)
+ */
+ this.cpR = function (fromPath, toPath, options) {
+ let from = path.normalize(fromPath);
+ let to = path.normalize(toPath);
+ let toStat;
+ let doesNotExistErr;
+ let filename;
+ let opts = options || {};
+
+ if (from == to) {
+ throw new Error('Cannot copy ' + from + ' to itself.');
+ }
+
+ // Handle rename-via-copy
+ try {
+ toStat = fs.statSync(to);
+ }
+ catch(e) {
+ doesNotExistErr = e;
+
+ // Get abs path so it's possible to check parent dir
+ if (!this.isAbsolute(to)) {
+ to = path.join(process.cwd(), to);
+ }
+
+ // Save the file/dir name
+ filename = path.basename(to);
+ // See if a parent dir exists, so there's a place to put the
+ /// renamed file/dir (resets the destination for the copy)
+ to = path.dirname(to);
+ try {
+ toStat = fs.statSync(to);
+ }
+ catch(e) {}
+ if (toStat && toStat.isDirectory()) {
+ // Set the rename opt to pass to the copy func, will be used
+ // as the new file/dir name
+ opts.rename = filename;
+ //console.log('filename ' + filename);
+ }
+ else {
+ throw doesNotExistErr;
+ }
+ }
+
+ _copyFile(from, to, opts);
+ };
+
+ /**
+ @name file#mkdirP
+ @public
+ @function
+ @description Create the given directory(ies) using the given mode permissions
+ @param {String} dir The directory to create
+ @param {Number} mode The mode to give the created directory(ies)(Default: 0755)
+ */
+ this.mkdirP = function (dir, mode) {
+ let dirPath = path.normalize(dir);
+ let paths = dirPath.split(/\/|\\/);
+ let currPath = '';
+ let next;
+
+ if (paths[0] == '' || /^[A-Za-z]+:/.test(paths[0])) {
+ currPath = paths.shift() || '/';
+ currPath = path.join(currPath, paths.shift());
+ //console.log('basedir');
+ }
+ while ((next = paths.shift())) {
+ if (next == '..') {
+ currPath = path.join(currPath, next);
+ continue;
+ }
+ currPath = path.join(currPath, next);
+ try {
+ //console.log('making ' + currPath);
+ fs.mkdirSync(currPath, mode || parseInt(755, 8));
+ }
+ catch(e) {
+ if (e.code != 'EEXIST') {
+ throw e;
+ }
+ }
+ }
+ };
+
+ /**
+ @name file#rmRf
+ @public
+ @function
+ @description Deletes the given directory/file
+ @param {String} p The path to delete, can be a directory or file
+ */
+ this.rmRf = function (p, options) {
+ let stat;
+ try {
+ stat = fs.lstatSync(p);
+ if (stat.isDirectory()) {
+ _rmDir(p);
+ }
+ else {
+ fs.unlinkSync(p);
+ }
+ }
+ catch (e) {}
+ };
+
+ /**
+ @name file#isAbsolute
+ @public
+ @function
+ @return {Boolean/String} If it's absolute the first character is returned otherwise false
+ @description Checks if a given path is absolute or relative
+ @param {String} p Path to check
+ */
+ this.isAbsolute = function (p) {
+ let match = /^[A-Za-z]+:\\|^\//.exec(p);
+ if (match && match.length) {
+ return match[0];
+ }
+ return false;
+ };
+
+ /**
+ @name file#absolutize
+ @public
+ @function
+ @return {String} Returns the absolute path for the given path
+ @description Returns the absolute path for the given path
+ @param {String} p The path to get the absolute path for
+ */
+ this.absolutize = function (p) {
+ if (this.isAbsolute(p)) {
+ return p;
+ }
+ else {
+ return path.join(process.cwd(), p);
+ }
+ };
+
+})();
+
+module.exports = fileUtils;
+
diff --git a/tools/ui/node_modules/jake/lib/utils/index.js b/tools/ui/node_modules/jake/lib/utils/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..17d686bdc5bc01b155e5426b47cc8ec96e2bc267
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/utils/index.js
@@ -0,0 +1,297 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+
+let util = require('util'); // Native Node util module
+let spawn = require('child_process').spawn;
+let EventEmitter = require('events').EventEmitter;
+let logger = require('./logger');
+let file = require('./file');
+let Exec;
+
+const _UUID_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
+
+let parseArgs = function (argumentsObj) {
+ let args;
+ let arg;
+ let cmds;
+ let callback;
+ let opts = {
+ interactive: false,
+ printStdout: false,
+ printStderr: false,
+ breakOnError: true
+ };
+
+ args = Array.prototype.slice.call(argumentsObj);
+
+ cmds = args.shift();
+ // Arrayize if passed a single string command
+ if (typeof cmds == 'string') {
+ cmds = [cmds];
+ }
+ // Make a copy if it's an actual list
+ else {
+ cmds = cmds.slice();
+ }
+
+ // Get optional callback or opts
+ while((arg = args.shift())) {
+ if (typeof arg == 'function') {
+ callback = arg;
+ }
+ else if (typeof arg == 'object') {
+ opts = Object.assign(opts, arg);
+ }
+ }
+
+ // Backward-compat shim
+ if (typeof opts.stdout != 'undefined') {
+ opts.printStdout = opts.stdout;
+ delete opts.stdout;
+ }
+ if (typeof opts.stderr != 'undefined') {
+ opts.printStderr = opts.stderr;
+ delete opts.stderr;
+ }
+
+ return {
+ cmds: cmds,
+ opts: opts,
+ callback: callback
+ };
+};
+
+/**
+ @name jake
+ @namespace jake
+*/
+let utils = new (function () {
+ /**
+ @name jake.exec
+ @static
+ @function
+ @description Executes shell-commands asynchronously with an optional
+ final callback.
+ `
+ @param {String[]} cmds The list of shell-commands to execute
+ @param {Object} [opts]
+ @param {Boolean} [opts.printStdout=false] Print stdout from each command
+ @param {Boolean} [opts.printStderr=false] Print stderr from each command
+ @param {Boolean} [opts.breakOnError=true] Stop further execution on
+ the first error.
+ @param {Boolean} [opts.windowsVerbatimArguments=false] Don't translate
+ arguments on Windows.
+ @param {Function} [callback] Callback to run after executing the
+ commands
+
+ @example
+ let cmds = [
+ 'echo "showing directories"'
+ , 'ls -al | grep ^d'
+ , 'echo "moving up a directory"'
+ , 'cd ../'
+ ]
+ , callback = function () {
+ console.log('Finished running commands.');
+ }
+ jake.exec(cmds, {stdout: true}, callback);
+ */
+ this.exec = function (a, b, c) {
+ let parsed = parseArgs(arguments);
+ let cmds = parsed.cmds;
+ let opts = parsed.opts;
+ let callback = parsed.callback;
+
+ let ex = new Exec(cmds, opts, callback);
+
+ ex.addListener('error', function (msg, code) {
+ if (opts.breakOnError) {
+ fail(msg, code);
+ }
+ });
+ ex.run();
+
+ return ex;
+ };
+
+ this.createExec = function (a, b, c) {
+ return new Exec(a, b, c);
+ };
+
+ // From Math.uuid.js, https://github.com/broofa/node-uuid
+ // Robert Kieffer (robert@broofa.com), MIT license
+ this.uuid = function (length, radix) {
+ var chars = _UUID_CHARS
+ , uuid = []
+ , r
+ , i;
+
+ radix = radix || chars.length;
+
+ if (length) {
+ // Compact form
+ i = -1;
+ while (++i < length) {
+ uuid[i] = chars[0 | Math.random()*radix];
+ }
+ } else {
+ // rfc4122, version 4 form
+
+ // rfc4122 requires these characters
+ uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
+ uuid[14] = '4';
+
+ // Fill in random data. At i==19 set the high bits of clock sequence as
+ // per rfc4122, sec. 4.1.5
+ i = -1;
+ while (++i < 36) {
+ if (!uuid[i]) {
+ r = 0 | Math.random()*16;
+ uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
+ }
+ }
+ }
+
+ return uuid.join('');
+ };
+
+})();
+
+Exec = function () {
+ let parsed = parseArgs(arguments);
+ let cmds = parsed.cmds;
+ let opts = parsed.opts;
+ let callback = parsed.callback;
+
+ this._cmds = cmds;
+ this._callback = callback;
+ this._config = opts;
+};
+
+util.inherits(Exec, EventEmitter);
+
+Object.assign(Exec.prototype, new (function () {
+
+ let _run = function () {
+ let self = this;
+ let sh;
+ let cmd;
+ let args;
+ let next = this._cmds.shift();
+ let config = this._config;
+ let errData = '';
+ let shStdio;
+ let handleStdoutData = function (data) {
+ self.emit('stdout', data);
+ };
+ let handleStderrData = function (data) {
+ let d = data.toString();
+ self.emit('stderr', data);
+ // Accumulate the error-data so we can use it as the
+ // stack if the process exits with an error
+ errData += d;
+ };
+
+ // Keep running as long as there are commands in the array
+ if (next) {
+ let spawnOpts = {};
+ this.emit('cmdStart', next);
+
+ // Ganking part of Node's child_process.exec to get cmdline args parsed
+ if (process.platform == 'win32') {
+ cmd = 'cmd';
+ args = ['/c', next];
+ if (config.windowsVerbatimArguments) {
+ spawnOpts.windowsVerbatimArguments = true;
+ }
+ }
+ else {
+ cmd = '/bin/sh';
+ args = ['-c', next];
+ }
+
+ if (config.interactive) {
+ spawnOpts.stdio = 'inherit';
+ sh = spawn(cmd, args, spawnOpts);
+ }
+ else {
+ shStdio = [
+ process.stdin
+ ];
+ if (config.printStdout) {
+ shStdio.push(process.stdout);
+ }
+ else {
+ shStdio.push('pipe');
+ }
+ if (config.printStderr) {
+ shStdio.push(process.stderr);
+ }
+ else {
+ shStdio.push('pipe');
+ }
+ spawnOpts.stdio = shStdio;
+ sh = spawn(cmd, args, spawnOpts);
+ if (!config.printStdout) {
+ sh.stdout.addListener('data', handleStdoutData);
+ }
+ if (!config.printStderr) {
+ sh.stderr.addListener('data', handleStderrData);
+ }
+ }
+
+ // Exit, handle err or run next
+ sh.on('exit', function (code) {
+ let msg;
+ if (code !== 0) {
+ msg = errData || 'Process exited with error.';
+ msg = msg.trim();
+ self.emit('error', msg, code);
+ }
+ if (code === 0 || !config.breakOnError) {
+ self.emit('cmdEnd', next);
+ setTimeout(function () { _run.call(self); }, 0);
+ }
+ });
+
+ }
+ else {
+ self.emit('end');
+ if (typeof self._callback == 'function') {
+ self._callback();
+ }
+ }
+ };
+
+ this.append = function (cmd) {
+ this._cmds.push(cmd);
+ };
+
+ this.run = function () {
+ _run.call(this);
+ };
+
+})());
+
+utils.Exec = Exec;
+utils.file = file;
+utils.logger = logger;
+
+module.exports = utils;
+
diff --git a/tools/ui/node_modules/jake/lib/utils/logger.js b/tools/ui/node_modules/jake/lib/utils/logger.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f72686fa83906a18633d1fad4bc4c0e082df1f1
--- /dev/null
+++ b/tools/ui/node_modules/jake/lib/utils/logger.js
@@ -0,0 +1,24 @@
+let util = require('util');
+
+let logger = new (function () {
+ let _output = function (type, out) {
+ let quiet = typeof jake != 'undefined' && jake.program &&
+ jake.program.opts && jake.program.opts.quiet;
+ let msg;
+ if (!quiet) {
+ msg = typeof out == 'string' ? out : util.inspect(out);
+ console[type](msg);
+ }
+ };
+
+ this.log = function (out) {
+ _output('log', out);
+ };
+
+ this.error = function (out) {
+ _output('error', out);
+ };
+
+})();
+
+module.exports = logger;
diff --git a/tools/ui/node_modules/jake/package.json b/tools/ui/node_modules/jake/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..d9d3e9e290caa5c0be1cda9629f43f79d1e45361
--- /dev/null
+++ b/tools/ui/node_modules/jake/package.json
@@ -0,0 +1,44 @@
+{
+ "name": "jake",
+ "description": "JavaScript build tool, similar to Make or Rake",
+ "keywords": [
+ "build",
+ "cli",
+ "make",
+ "rake"
+ ],
+ "version": "10.9.4",
+ "author": "Matthew Eernisse (http://fleegix.org)",
+ "license": "Apache-2.0",
+ "bin": {
+ "jake": "./bin/cli.js"
+ },
+ "main": "./lib/jake.js",
+ "scripts": {
+ "lint": "eslint --format codeframe \"lib/**/*.js\" \"test/**/*.js\"",
+ "lint:fix": "eslint --fix \"lib/**/*.js\" \"test/**/*.js\"",
+ "test": "./bin/cli.js test",
+ "test:ci": "npm run lint && npm run test"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/jakejs/jake.git"
+ },
+ "preferGlobal": true,
+ "dependencies": {
+ "async": "^3.2.6",
+ "filelist": "^1.0.4",
+ "picocolors": "^1.1.1"
+ },
+ "devDependencies": {
+ "@eslint/js": "^9.16.0",
+ "eslint": "^9.16.0",
+ "eslint-formatter-codeframe": "^7.32.1",
+ "globals": "^15.13.0",
+ "mocha": "^11.0.1",
+ "q": "^1.5.1"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+}
diff --git a/tools/ui/node_modules/jake/test/integration/concurrent.js b/tools/ui/node_modules/jake/test/integration/concurrent.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab649b9c606736d289427367b20b8f5732d20d96
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/concurrent.js
@@ -0,0 +1,45 @@
+let assert = require('assert');
+let exec = require('child_process').execSync;
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+suite('concurrent', function () {
+
+ this.timeout(7000);
+
+ test(' simple concurrent prerequisites 1', function () {
+ let out = exec(`${JAKE_CMD} -q concurrent:simple1`).toString().trim();
+ assert.equal('Started A\nStarted B\nFinished B\nFinished A', out);
+ });
+
+ test(' simple concurrent prerequisites 2', function () {
+ let out = exec(`${JAKE_CMD} -q concurrent:simple2`).toString().trim();
+ assert.equal('Started C\nStarted D\nFinished C\nFinished D', out);
+ });
+
+ test(' sequential concurrent prerequisites', function () {
+ let out = exec(`${JAKE_CMD} -q concurrent:seqconcurrent`).toString().trim();
+ assert.equal('Started A\nStarted B\nFinished B\nFinished A\nStarted C\nStarted D\nFinished C\nFinished D', out);
+ });
+
+ test(' concurrent concurrent prerequisites', function () {
+ let out = exec(`${JAKE_CMD} -q concurrent:concurrentconcurrent`).toString().trim();
+ assert.equal('Started A\nStarted B\nStarted C\nStarted D\nFinished B\nFinished C\nFinished A\nFinished D', out);
+ });
+
+ test(' concurrent prerequisites with subdependency', function () {
+ let out = exec(`${JAKE_CMD} -q concurrent:subdep`).toString().trim();
+ assert.equal('Started A\nFinished A\nStarted Ba\nFinished Ba', out);
+ });
+
+ test(' failing in concurrent prerequisites', function () {
+ try {
+ exec(`${JAKE_CMD} -q concurrent:Cfail`);
+ }
+ catch(err) {
+ assert(err.message.indexOf('Command failed') > -1);
+ }
+ });
+
+});
diff --git a/tools/ui/node_modules/jake/test/integration/file.js b/tools/ui/node_modules/jake/test/integration/file.js
new file mode 100644
index 0000000000000000000000000000000000000000..97ed0d63b30734d055ebaab4c0ab2c160af69a3e
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/file.js
@@ -0,0 +1,228 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+
+let assert = require('assert');
+let fs = require('fs');
+let path = require('path');
+let file = require(`${PROJECT_DIR}/lib/utils/file`);
+let existsSync = fs.existsSync || path.existsSync;
+let exec = require('child_process').execSync;
+
+suite('fileUtils', function () {
+
+ test('mkdirP', function () {
+ let expected = [
+ ['foo'],
+ ['foo', 'bar'],
+ ['foo', 'bar', 'baz'],
+ ['foo', 'bar', 'baz', 'qux']
+ ];
+ file.mkdirP('foo/bar/baz/qux');
+ let res = exec('find foo').toString().trim().split('\n');
+ for (let i = 0, ii = res.length; i < ii; i++) {
+ assert.equal(path.join.apply(path, expected[i]), res[i]);
+ }
+ file.rmRf('foo');
+ });
+
+ test('rmRf', function () {
+ file.mkdirP('foo/bar/baz/qux');
+ file.rmRf('foo/bar');
+ let res = exec('find foo').toString().trim().split('\n');
+ assert.equal(1, res.length);
+ assert.equal('foo', res[0]);
+ fs.rmdirSync('foo');
+ });
+
+ test('rmRf with symlink subdir', function () {
+ file.mkdirP('foo');
+ file.mkdirP('bar');
+ fs.writeFileSync('foo/hello.txt', 'hello, it\'s me');
+ fs.symlinkSync('../foo', 'bar/foo'); file.rmRf('bar');
+
+ // Make sure the bar directory was successfully deleted
+ let barDeleted = false;
+ try {
+ fs.statSync('bar');
+ } catch(err) {
+ if(err.code == 'ENOENT') {
+ barDeleted = true;
+ }
+ }
+ assert.equal(true, barDeleted);
+
+ // Make sure that the file inside the linked folder wasn't deleted
+ let res = fs.readdirSync('foo');
+ assert.equal(1, res.length);
+ assert.equal('hello.txt', res[0]);
+
+ // Cleanup
+ fs.unlinkSync('foo/hello.txt');
+ fs.rmdirSync('foo');
+ });
+
+ test('rmRf with symlinked dir', function () {
+ file.mkdirP('foo');
+ fs.writeFileSync('foo/hello.txt', 'hello!');
+ fs.symlinkSync('foo', 'bar');
+ file.rmRf('bar');
+
+ // Make sure the bar directory was successfully deleted
+ let barDeleted = false;
+ try {
+ fs.statSync('bar');
+ } catch(err) {
+ if(err.code == 'ENOENT') {
+ barDeleted = true;
+ }
+ }
+ assert.equal(true, barDeleted);
+
+ // Make sure that the file inside the linked folder wasn't deleted
+ let res = fs.readdirSync('foo');
+ assert.equal(1, res.length);
+ assert.equal('hello.txt', res[0]);
+
+ // Cleanup
+ fs.unlinkSync('foo/hello.txt');
+ fs.rmdirSync('foo');
+ });
+
+ test('cpR with same name and different directory', function () {
+ file.mkdirP('foo');
+ fs.writeFileSync('foo/bar.txt', 'w00t');
+ file.cpR('foo', 'bar');
+ assert.ok(existsSync('bar/bar.txt'));
+ file.rmRf('foo');
+ file.rmRf('bar');
+ });
+
+ test('cpR with same to and from will throw', function () {
+ assert.throws(function () {
+ file.cpR('foo.txt', 'foo.txt');
+ });
+ });
+
+ test('cpR rename via copy in directory', function () {
+ file.mkdirP('foo');
+ fs.writeFileSync('foo/bar.txt', 'w00t');
+ file.cpR('foo/bar.txt', 'foo/baz.txt');
+ assert.ok(existsSync('foo/baz.txt'));
+ file.rmRf('foo');
+ });
+
+ test('cpR rename via copy in base', function () {
+ fs.writeFileSync('bar.txt', 'w00t');
+ file.cpR('bar.txt', 'baz.txt');
+ assert.ok(existsSync('baz.txt'));
+ file.rmRf('bar.txt');
+ file.rmRf('baz.txt');
+ });
+
+ test('cpR keeps file mode', function () {
+ fs.writeFileSync('bar.txt', 'w00t', {mode: 0o750});
+ fs.writeFileSync('bar1.txt', 'w00t!', {mode: 0o744});
+ file.cpR('bar.txt', 'baz.txt');
+ file.cpR('bar1.txt', 'baz1.txt');
+
+ assert.ok(existsSync('baz.txt'));
+ assert.ok(existsSync('baz1.txt'));
+ let bazStat = fs.statSync('baz.txt');
+ let bazStat1 = fs.statSync('baz1.txt');
+ assert.equal(0o750, bazStat.mode & 0o7777);
+ assert.equal(0o744, bazStat1.mode & 0o7777);
+
+ file.rmRf('bar.txt');
+ file.rmRf('baz.txt');
+ file.rmRf('bar1.txt');
+ file.rmRf('baz1.txt');
+ });
+
+ test('cpR keeps file mode when overwriting with preserveMode', function () {
+ fs.writeFileSync('bar.txt', 'w00t', {mode: 0o755});
+ fs.writeFileSync('baz.txt', 'w00t!', {mode: 0o744});
+ file.cpR('bar.txt', 'baz.txt', {silent: true, preserveMode: true});
+
+ assert.ok(existsSync('baz.txt'));
+ let bazStat = fs.statSync('baz.txt');
+ assert.equal(0o755, bazStat.mode & 0o777);
+
+ file.rmRf('bar.txt');
+ file.rmRf('baz.txt');
+ });
+
+ test('cpR does not keep file mode when overwriting', function () {
+ fs.writeFileSync('bar.txt', 'w00t', {mode: 0o766});
+ fs.writeFileSync('baz.txt', 'w00t!', {mode: 0o744});
+ file.cpR('bar.txt', 'baz.txt');
+
+ assert.ok(existsSync('baz.txt'));
+ let bazStat = fs.statSync('baz.txt');
+ assert.equal(0o744, bazStat.mode & 0o777);
+
+ file.rmRf('bar.txt');
+ file.rmRf('baz.txt');
+ });
+
+ test('cpR copies file mode recursively', function () {
+ fs.mkdirSync('foo');
+ fs.writeFileSync('foo/bar.txt', 'w00t', {mode: 0o740});
+ file.cpR('foo', 'baz');
+
+ assert.ok(existsSync('baz'));
+ let barStat = fs.statSync('baz/bar.txt');
+ assert.equal(0o740, barStat.mode & 0o777);
+
+ file.rmRf('foo');
+ file.rmRf('baz');
+ });
+
+ test('cpR keeps file mode recursively', function () {
+ fs.mkdirSync('foo');
+ fs.writeFileSync('foo/bar.txt', 'w00t', {mode: 0o740});
+ fs.mkdirSync('baz');
+ fs.mkdirSync('baz/foo');
+ fs.writeFileSync('baz/foo/bar.txt', 'w00t!', {mode: 0o755});
+ file.cpR('foo', 'baz', {silent: true, preserveMode: true});
+
+ assert.ok(existsSync('baz'));
+ let barStat = fs.statSync('baz/foo/bar.txt');
+ assert.equal(0o740, barStat.mode & 0o777);
+
+ file.rmRf('foo');
+ file.rmRf('baz');
+ });
+
+ test('cpR copies directory mode recursively', function () {
+ fs.mkdirSync('foo', 0o755);
+ fs.mkdirSync('foo/bar', 0o700);
+ file.cpR('foo', 'bar');
+
+ assert.ok(existsSync('foo'));
+ let fooBarStat = fs.statSync('bar/bar');
+ assert.equal(0o700, fooBarStat.mode & 0o777);
+
+ file.rmRf('foo');
+ file.rmRf('bar');
+ });
+
+});
+
+
diff --git a/tools/ui/node_modules/jake/test/integration/file_task.js b/tools/ui/node_modules/jake/test/integration/file_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b5608ee430090de65dd2574a81590db7c151e8d
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/file_task.js
@@ -0,0 +1,141 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+let assert = require('assert');
+let fs = require('fs');
+let exec = require('child_process').execSync;
+let { rmRf } = require(`${PROJECT_DIR}/lib/jake`);
+
+let cleanUpAndNext = function (callback) {
+ rmRf('./foo', {
+ silent: true
+ });
+ callback && callback();
+};
+
+suite('fileTask', function () {
+ this.timeout(7000);
+
+ setup(function () {
+ cleanUpAndNext();
+ });
+
+ test('where a file-task prereq does not change with --always-make', function () {
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-src1.txt`).toString().trim();
+ assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task',
+ out);
+ out = exec(`${JAKE_CMD} -q -B fileTest:foo/from-src1.txt`).toString().trim();
+ assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task',
+ out);
+ cleanUpAndNext();
+ });
+
+ test('concating two files', function () {
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/concat.txt`).toString().trim();
+ assert.equal('fileTest:foo/src1.txt task\ndefault task\nfileTest:foo/src2.txt task\n' +
+ 'fileTest:foo/concat.txt task', out);
+ // Check to see the two files got concat'd
+ let data = fs.readFileSync(process.cwd() + '/foo/concat.txt');
+ assert.equal('src1src2', data.toString());
+ cleanUpAndNext();
+ });
+
+ test('where a file-task prereq does not change', function () {
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-src1.txt`).toString().trim();
+ assert.equal('fileTest:foo/src1.txt task\nfileTest:foo/from-src1.txt task', out);
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-src1.txt`).toString().trim();
+ // Second time should be a no-op
+ assert.equal('', out);
+ cleanUpAndNext();
+ });
+
+ test('where a file-task prereq does change, then does not', function (next) {
+ exec('mkdir -p ./foo');
+ exec('touch ./foo/from-src1.txt');
+ setTimeout(() => {
+ fs.writeFileSync('./foo/src1.txt', '-SRC');
+ // Task should run the first time
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-src1.txt`).toString().trim();
+ assert.equal('fileTest:foo/from-src1.txt task', out);
+ // Task should not run on subsequent invocation
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-src1.txt`).toString().trim();
+ assert.equal('', out);
+ cleanUpAndNext(next);
+ }, 1000);
+ });
+
+ test('a preexisting file', function () {
+ let prereqData = 'howdy';
+ exec('mkdir -p ./foo');
+ fs.writeFileSync('foo/prereq.txt', prereqData);
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-prereq.txt`).toString().trim();
+ assert.equal('fileTest:foo/from-prereq.txt task', out);
+ let data = fs.readFileSync(process.cwd() + '/foo/from-prereq.txt');
+ assert.equal(prereqData, data.toString());
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-prereq.txt`).toString().trim();
+ // Second time should be a no-op
+ assert.equal('', out);
+ cleanUpAndNext();
+ });
+
+ test('a preexisting file with --always-make flag', function () {
+ let prereqData = 'howdy';
+ exec('mkdir -p ./foo');
+ fs.writeFileSync('foo/prereq.txt', prereqData);
+ let out;
+ out = exec(`${JAKE_CMD} -q fileTest:foo/from-prereq.txt`).toString().trim();
+ assert.equal('fileTest:foo/from-prereq.txt task', out);
+ let data = fs.readFileSync(process.cwd() + '/foo/from-prereq.txt');
+ assert.equal(prereqData, data.toString());
+ out = exec(`${JAKE_CMD} -q -B fileTest:foo/from-prereq.txt`).toString().trim();
+ assert.equal('fileTest:foo/from-prereq.txt task', out);
+ cleanUpAndNext();
+ });
+
+ test('nested directory-task', function () {
+ exec(`${JAKE_CMD} -q fileTest:foo/bar/baz/bamf.txt`);
+ let data = fs.readFileSync(process.cwd() + '/foo/bar/baz/bamf.txt');
+ assert.equal('w00t', data);
+ cleanUpAndNext();
+ });
+
+ test('partially existing prereqs', function () {
+ /*
+ dependency graph:
+ /-- foo/output2a.txt --\
+ foo -- foo/output1.txt --+ +-- output3.txt
+ \-- foo/output2b.txt --/
+ */
+ // build part of the prereqs
+ exec(`${JAKE_CMD} -q fileTest:foo/output2a.txt`);
+ // verify the final target gets built
+ exec(`${JAKE_CMD} -q fileTest:foo/output3.txt`);
+ let data = fs.readFileSync(process.cwd() + '/foo/output3.txt');
+ assert.equal('w00t', data);
+ cleanUpAndNext();
+ });
+});
+
diff --git a/tools/ui/node_modules/jake/test/integration/helpers.js b/tools/ui/node_modules/jake/test/integration/helpers.js
new file mode 100644
index 0000000000000000000000000000000000000000..9caaa4e7fe5e7085acf61b52d886c63a3166b3da
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/helpers.js
@@ -0,0 +1,80 @@
+var exec = require('child_process').exec;
+
+var helpers = new (function () {
+ var _tests;
+ var _names = [];
+ var _name;
+ var _callback;
+ var _runner = function () {
+ if ((_name = _names.shift())) {
+ console.log('Running ' + _name);
+ _tests[_name]();
+ }
+ else {
+ _callback();
+ }
+ };
+
+ this.exec = function () {
+ var args = Array.prototype.slice.call(arguments);
+ var arg;
+ var cmd = args.shift();
+ var opts = {};
+ var callback;
+ // Optional opts/callback or callback/opts
+ while ((arg = args.shift())) {
+ if (typeof arg == 'function') {
+ callback = arg;
+ }
+ else {
+ opts = arg;
+ }
+ }
+
+ cmd += ' --trace';
+ var execOpts = opts.execOpts ? opts.execOpts : {};
+ exec(cmd, execOpts, function (err, stdout, stderr) {
+ var out = helpers.trim(stdout);
+ if (err) {
+ if (opts.breakOnError === false) {
+ return callback(err);
+ }
+ else {
+ throw err;
+ }
+ }
+ if (stderr) {
+ callback(stderr);
+ }
+ else {
+ callback(out);
+ }
+ });
+ };
+
+ this.trim = function (s) {
+ var str = s || '';
+ return str.replace(/^\s*|\s*$/g, '');
+ };
+
+ this.parse = function (s) {
+ var str = s || '';
+ str = helpers.trim(str);
+ str = str.replace(/'/g, '"');
+ return JSON.parse(str);
+ };
+
+ this.run = function (tests, callback) {
+ _tests = tests;
+ _names = Object.keys(tests);
+ _callback = callback;
+ _runner();
+ };
+
+ this.next = function () {
+ _runner();
+ };
+
+})();
+
+module.exports = helpers;
diff --git a/tools/ui/node_modules/jake/test/integration/jakefile.js b/tools/ui/node_modules/jake/test/integration/jakefile.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d57d0ab04da7f4ed6598e89a231019a902ef894
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/jakefile.js
@@ -0,0 +1,352 @@
+let fs = require('fs');
+let Q = require('q');
+
+desc('The default t.');
+task('default', function () {
+ console.log('default task');
+});
+
+desc('No action.');
+task({'noAction': ['default']});
+
+desc('No action, no prereqs.');
+task('noActionNoPrereqs');
+
+desc('Top-level zerbofrangazoomy task');
+task('zerbofrangazoomy', function () {
+ console.log('Whaaaaaaaa? Ran the zerbofrangazoomy task!');
+});
+
+desc('Task that throws');
+task('throwy', function () {
+ let errorListener = function (err) {
+ console.log('Emitted');
+ console.log(err.toString());
+
+ jake.removeListener('error', errorListener);
+ };
+
+ jake.on('error', errorListener);
+
+ throw new Error('I am bad');
+});
+
+desc('Task that rejects a Promise');
+task('promiseRejecter', function () {
+ const originalOption = jake.program.opts['allow-rejection'];
+
+ const errorListener = function (err) {
+ console.log(err.toString());
+ jake.removeListener('error', errorListener);
+ jake.program.opts['allow-rejection'] = originalOption; // Restore original 'allow-rejection' option
+ };
+ jake.on('error', errorListener);
+
+ jake.program.opts['allow-rejection'] = false; // Do not allow rejection so the rejection is passed to error handlers
+
+ Promise.reject('');
+});
+
+desc('Accepts args and env vars.');
+task('argsEnvVars', function () {
+ let res = {
+ args: arguments
+ , env: {
+ foo: process.env.foo
+ , baz: process.env.baz
+ }
+ };
+ console.log(JSON.stringify(res));
+});
+
+namespace('foo', function () {
+ desc('The foo:bar t.');
+ task('bar', function () {
+ if (arguments.length) {
+ console.log('foo:bar[' +
+ Array.prototype.join.call(arguments, ',') +
+ '] task');
+ }
+ else {
+ console.log('foo:bar task');
+ }
+ });
+
+ desc('The foo:baz task, calls foo:bar as a prerequisite.');
+ task('baz', ['foo:bar'], function () {
+ console.log('foo:baz task');
+ });
+
+ desc('The foo:qux task, calls foo:bar with cmdline args as a prerequisite.');
+ task('qux', ['foo:bar[asdf,qwer]'], function () {
+ console.log('foo:qux task');
+ });
+
+ desc('The foo:frang task,`invokes` foo:bar with passed args as a prerequisite.');
+ task('frang', function () {
+ let t = jake.Task['foo:bar'];
+ // Do args pass-through
+ t.invoke.apply(t, arguments);
+ t.on('complete', () => {
+ console.log('foo:frang task');
+ });
+ });
+
+ desc('The foo:zerb task, `executes` foo:bar with passed args as a prerequisite.');
+ task('zerb', function () {
+ let t = jake.Task['foo:bar'];
+ // Do args pass-through
+ t.execute.apply(t, arguments);
+ t.on('complete', () => {
+ console.log('foo:zerb task');
+ });
+ });
+
+ desc('The foo:zoobie task, has no prerequisites.');
+ task('zoobie', function () {
+ console.log('foo:zoobie task');
+ });
+
+ desc('The foo:voom task, run the foo:zoobie task repeatedly.');
+ task('voom', function () {
+ let t = jake.Task['foo:bar'];
+ t.on('complete', function () {
+ console.log('complete');
+ });
+ t.execute.apply(t);
+ t.execute.apply(t);
+ });
+
+ desc('The foo:asdf task, has the same prereq twice.');
+ task('asdf', ['foo:bar', 'foo:baz'], function () {
+ console.log('foo:asdf task');
+ });
+
+});
+
+namespace('bar', function () {
+ desc('The bar:foo task, has no prerequisites, is async, returns Promise which resolves.');
+ task('foo', async function () {
+ return new Promise((resolve, reject) => {
+ console.log('bar:foo task');
+ resolve();
+ });
+ });
+
+ desc('The bar:promise task has no prerequisites, is async, returns Q-based promise.');
+ task('promise', function () {
+ return Q()
+ .then(function () {
+ console.log('bar:promise task');
+ return 123654;
+ });
+ });
+
+ desc('The bar:dependOnpromise task waits for a promise based async test');
+ task('dependOnpromise', ['promise'], function () {
+ console.log('bar:dependOnpromise task saw value', jake.Task["bar:promise"].value);
+ });
+
+ desc('The bar:brokenPromise task is a failing Q-promise based async task.');
+ task('brokenPromise', function () {
+ return Q()
+ .then(function () {
+ throw new Error("nom nom nom");
+ });
+ });
+
+ desc('The bar:bar task, has the async bar:foo task as a prerequisite.');
+ task('bar', ['bar:foo'], function () {
+ console.log('bar:bar task');
+ });
+
+});
+
+namespace('hoge', function () {
+ desc('The hoge:hoge task, has no prerequisites.');
+ task('hoge', function () {
+ console.log('hoge:hoge task');
+ });
+
+ desc('The hoge:piyo task, has no prerequisites.');
+ task('piyo', function () {
+ console.log('hoge:piyo task');
+ });
+
+ desc('The hoge:fuga task, has hoge:hoge and hoge:piyo as prerequisites.');
+ task('fuga', ['hoge:hoge', 'hoge:piyo'], function () {
+ console.log('hoge:fuga task');
+ });
+
+ desc('The hoge:charan task, has hoge:fuga as a prerequisite.');
+ task('charan', ['hoge:fuga'], function () {
+ console.log('hoge:charan task');
+ });
+
+ desc('The hoge:gero task, has hoge:fuga as a prerequisite.');
+ task('gero', ['hoge:fuga'], function () {
+ console.log('hoge:gero task');
+ });
+
+ desc('The hoge:kira task, has hoge:charan and hoge:gero as prerequisites.');
+ task('kira', ['hoge:charan', 'hoge:gero'], function () {
+ console.log('hoge:kira task');
+ });
+
+});
+
+namespace('fileTest', function () {
+ directory('foo');
+
+ desc('File task, concatenating two files together');
+ file('foo/concat.txt', ['fileTest:foo', 'fileTest:foo/src1.txt', 'fileTest:foo/src2.txt'], function () {
+ console.log('fileTest:foo/concat.txt task');
+ let data1 = fs.readFileSync('foo/src1.txt');
+ let data2 = fs.readFileSync('foo/src2.txt');
+ fs.writeFileSync('foo/concat.txt', data1 + data2);
+ });
+
+ desc('File task, async creation with writeFile');
+ file('foo/src1.txt', function () {
+ return new Promise(function (resolve, reject) {
+ fs.writeFile('foo/src1.txt', 'src1', function (err) {
+ if (err) {
+ reject(err);
+ }
+ else {
+ console.log('fileTest:foo/src1.txt task');
+ resolve();
+ }
+ });
+ });
+ });
+
+ desc('File task, sync creation with writeFileSync');
+ file('foo/src2.txt', ['default'], function () {
+ fs.writeFileSync('foo/src2.txt', 'src2');
+ console.log('fileTest:foo/src2.txt task');
+ });
+
+ desc('File task, do not run unless the prereq file changes');
+ file('foo/from-src1.txt', ['fileTest:foo', 'fileTest:foo/src1.txt'], function () {
+ let data = fs.readFileSync('foo/src1.txt').toString();
+ fs.writeFileSync('foo/from-src1.txt', data);
+ console.log('fileTest:foo/from-src1.txt task');
+ });
+
+ desc('File task, run if the prereq file changes');
+ task('touch-prereq', function () {
+ fs.writeFileSync('foo/prereq.txt', 'UPDATED');
+ });
+
+ desc('File task, has a preexisting file (with no associated task) as a prereq');
+ file('foo/from-prereq.txt', ['fileTest:foo', 'foo/prereq.txt'], function () {
+ let data = fs.readFileSync('foo/prereq.txt');
+ fs.writeFileSync('foo/from-prereq.txt', data);
+ console.log('fileTest:foo/from-prereq.txt task');
+ });
+
+ directory('foo/bar/baz');
+
+ desc('Write a file in a nested subdirectory');
+ file('foo/bar/baz/bamf.txt', ['foo/bar/baz'], function () {
+ fs.writeFileSync('foo/bar/baz/bamf.txt', 'w00t');
+ });
+
+ file('foo/output1.txt', ['foo'], () => {
+ fs.writeFileSync('foo/output1.txt', 'Contents of foo/output1.txt');
+ });
+
+ file('foo/output2a.txt', ['foo/output1.txt'], () => {
+ fs.writeFileSync('foo/output2a.txt', 'Contents of foo/output2a.txt');
+ });
+
+ file('foo/output2b.txt', ['foo/output1.txt'], () => {
+ fs.writeFileSync('foo/output2b.txt', 'Contents of foo/output2b.txt');
+ });
+
+ file('foo/output3.txt', [ 'foo/output2a.txt', 'foo/output2b.txt'], () => {
+ fs.writeFileSync('foo/output3.txt', 'w00t');
+ });
+});
+
+task('blammo');
+// Define task
+task('voom', ['blammo'], function () {
+ console.log(this.prereqs.length);
+});
+
+// Modify, add a prereq
+task('voom', ['noActionNoPrereqs']);
+
+namespace('vronk', function () {
+ task('groo', function () {
+ let t = jake.Task['vronk:zong'];
+ t.addListener('error', function (e) {
+ console.log(e.message);
+ });
+ t.invoke();
+ });
+ task('zong', function () {
+ throw new Error('OMFGZONG');
+ });
+});
+
+// define namespace
+namespace('one', function () {
+ task('one', function () {
+ console.log('one:one');
+ });
+});
+
+// modify namespace (add task)
+namespace('one', function () {
+ task('two', ['one:one'], function () {
+ console.log('one:two');
+ });
+});
+
+task('selfdepconst', [], function () {
+ task('selfdep', ['selfdep'], function () {
+ console.log("I made a task that depends on itself");
+ });
+});
+task('selfdepdyn', function () {
+ task('selfdeppar', [], {concurrency: 2}, function () {
+ console.log("I will depend on myself and will fail at runtime");
+ });
+ task('selfdeppar', ['selfdeppar']);
+ jake.Task['selfdeppar'].invoke();
+});
+
+namespace("large", function () {
+ task("leaf", function () {
+ console.log("large:leaf");
+ });
+
+ const same = [];
+ for (let i = 0; i < 2000; i++) {
+ same.push("leaf");
+ }
+
+ desc("Task with a large number of same prereqs");
+ task("same", same, { concurrency: 2 }, function () {
+ console.log("large:same");
+ });
+
+ const different = [];
+ for (let i = 0; i < 2000; i++) {
+ const name = "leaf-" + i;
+ task(name, function () {
+ if (name === "leaf-12" || name === "leaf-123") {
+ console.log(name);
+ }
+ });
+ different.push(name);
+ }
+
+ desc("Task with a large number of different prereqs");
+ task("different", different, { concurrency: 2 } , function () {
+ console.log("large:different");
+ });
+});
diff --git a/tools/ui/node_modules/jake/test/integration/jakelib/concurrent.jake.js b/tools/ui/node_modules/jake/test/integration/jakelib/concurrent.jake.js
new file mode 100644
index 0000000000000000000000000000000000000000..684c86f1a18327dd3566fb1d2b5a20206179d020
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/jakelib/concurrent.jake.js
@@ -0,0 +1,113 @@
+
+namespace('concurrent', function () {
+ task('A', function () {
+ console.log('Started A');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Finished A');
+ resolve();
+ }, 200);
+ });
+ });
+
+ task('B', function () {
+ console.log('Started B');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Finished B');
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('C', function () {
+ console.log('Started C');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Finished C');
+ resolve();
+ }, 100);
+ });
+ });
+
+ task('D', function () {
+ console.log('Started D');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Finished D');
+ resolve();
+ }, 300);
+ });
+ });
+
+ task('Ba', ['A'], function () {
+ console.log('Started Ba');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Finished Ba');
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('Afail', function () {
+ console.log('Started failing task');
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ console.log('Failing B with error');
+ throw new Error('I failed');
+ }, 50);
+ });
+ });
+
+ task('simple1', ['A','B'], {concurrency: 2}, function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('simple2', ['C','D'], {concurrency: 2}, function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('seqconcurrent', ['simple1','simple2'], function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('concurrentconcurrent', ['simple1','simple2'], {concurrency: 2}, function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('subdep', ['A','Ba'], {concurrency: 2}, function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+ task('fail', ['A', 'B', 'Afail'], {concurrency: 3}, function () {
+ return new Promise((resolve, reject) => {
+ setTimeout(() => {
+ resolve();
+ }, 50);
+ });
+ });
+
+});
+
+
diff --git a/tools/ui/node_modules/jake/test/integration/jakelib/publish.jake.js b/tools/ui/node_modules/jake/test/integration/jakelib/publish.jake.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8485d1cf300a3760acaffda954b8ce20272711c
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/jakelib/publish.jake.js
@@ -0,0 +1,49 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+
+let fs = require('fs');
+let { publishTask, rmRf, mkdirP } = require(`${PROJECT_DIR}/lib/jake`);
+
+fs.writeFileSync('package.json', '{"version": "0.0.1"}');
+mkdirP('tmp_publish');
+fs.writeFileSync('tmp_publish/foo.txt', 'FOO');
+
+publishTask('zerb', function () {
+ this.packageFiles.include([
+ 'package.json'
+ , 'tmp_publish/**'
+ ]);
+ this.publishCmd = 'node -p -e "\'%filename\'"';
+ this.gitCmd = 'echo';
+ this.scheduleDelay = 0;
+
+ this._ensureRepoClean = function () {};
+ this._getCurrentBranch = function () {
+ return 'v0.0';
+ };
+});
+
+jake.setTaskTimeout(5000);
+
+jake.Task['publish'].on('complete', function () {
+ rmRf('tmp_publish', {silent: true});
+ rmRf('package.json', {silent: true});
+});
+
diff --git a/tools/ui/node_modules/jake/test/integration/jakelib/required_module.jake.js b/tools/ui/node_modules/jake/test/integration/jakelib/required_module.jake.js
new file mode 100644
index 0000000000000000000000000000000000000000..eae666ba248d2001dedcce2fd3080e06e850d94c
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/jakelib/required_module.jake.js
@@ -0,0 +1,10 @@
+let { task, namespace } = require(`${process.env.PROJECT_DIR}/lib/jake`);
+
+namespace('usingRequire', function () {
+ task('test', () => {
+ console.log('howdy test');
+ });
+});
+
+
+
diff --git a/tools/ui/node_modules/jake/test/integration/jakelib/rule.jake.js b/tools/ui/node_modules/jake/test/integration/jakelib/rule.jake.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e977dd95a5c5777d327885551c792aba8e3096b
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/jakelib/rule.jake.js
@@ -0,0 +1,222 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+
+let exec = require('child_process').execSync;
+let fs = require('fs');
+let util = require('util');
+let { rule, rmRf } = require(`${PROJECT_DIR}/lib/jake`);
+
+directory('tmpsrc');
+directory('tmpbin');
+
+////////////////////////////////////////////////////////////
+// Simple Suffix Rule
+file('tmp', ['tmp_init', 'tmp_dep1.o', 'tmp_dep2.o'], function (params) {
+ console.log('tmp task');
+ let data1 = fs.readFileSync('tmp_dep1.o');
+ let data2 = fs.readFileSync('tmp_dep2.o');
+ fs.writeFileSync('tmp', data1 + data2);
+});
+
+rule('.o', '.c', function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' task');
+ exec(cmd);
+});
+
+file('tmp_dep1.c', function () {
+ fs.writeFileSync('tmp_dep1.c', 'src_1');
+ console.log('tmp_dep1.c task');
+});
+
+// note that tmp_dep2.o depends on tmp_dep2.c, which is a
+// static file.
+task('tmp_init', function () {
+ fs.writeFileSync('tmp_dep2.c', 'src_2');
+ console.log('tmp_dep2.c task');
+});
+////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+// Pattern Rule
+file('tmp_p', ['tmp_init', 'tmp_dep1.oo', 'tmp_dep2.oo'], function (params) {
+ console.log('tmp pattern task');
+ let data1 = fs.readFileSync('tmp_dep1.oo');
+ let data2 = fs.readFileSync('tmp_dep2.oo');
+ fs.writeFileSync('tmp_p', data1 + data2 + ' pattern');
+});
+
+rule('%.oo', '%.c', function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' task');
+ exec(cmd);
+});
+////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+// Pattern Rule with Folder
+// i.e. rule('tmpbin/%.oo', 'tmpsrc/%.c', ...
+file('tmp_pf', [
+ 'tmp_src_init'
+ , 'tmpbin'
+ , 'tmpbin/tmp_dep1.oo'
+ , 'tmpbin/tmp_dep2.oo' ], function (params) {
+ console.log('tmp pattern folder task');
+ let data1 = fs.readFileSync('tmpbin/tmp_dep1.oo');
+ let data2 = fs.readFileSync('tmpbin/tmp_dep2.oo');
+ fs.writeFileSync('tmp_pf', data1 + data2 + ' pattern folder');
+});
+
+rule('tmpbin/%.oo', 'tmpsrc/%.c', function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' task');
+ exec(cmd);
+});
+
+file('tmpsrc/tmp_dep2.c',['tmpsrc'], function () {
+ fs.writeFileSync('tmpsrc/tmp_dep2.c', 'src/src_2');
+ console.log('tmpsrc/tmp_dep2.c task');
+});
+
+// Create static files in folder tmpsrc.
+task('tmp_src_init', ['tmpsrc'], function () {
+ fs.writeFileSync('tmpsrc/tmp_dep1.c', 'src/src_1');
+ console.log('tmpsrc/tmp_dep1.c task');
+});
+////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////
+// Namespace Test. This is a Mixed Test.
+// Test for
+// - rules belonging to different namespace.
+// - rules with folder and pattern
+task('tmp_ns', [
+ 'tmpbin'
+ , 'rule:init'
+ , 'tmpbin/tmp_dep2.oo' // *** This relies on a rule defined before.
+ , 'rule:tmpbin/dep1.oo'
+ , 'rule:tmpbin/file2.oo' ], function () {
+ console.log('tmp pattern folder namespace task');
+ let data1 = fs.readFileSync('tmpbin/dep1.oo');
+ let data2 = fs.readFileSync('tmpbin/tmp_dep2.oo');
+ let data3 = fs.readFileSync('tmpbin/file2.oo');
+ fs.writeFileSync('tmp_ns', data1 + data2 + data3 + ' pattern folder namespace');
+});
+
+namespace('rule', function () {
+ task('init', ['tmpsrc'], function () {
+ fs.writeFileSync('tmpsrc/file2.c', 'src/src_3');
+ console.log('tmpsrc/file2.c init task');
+ });
+
+ file('tmpsrc/dep1.c',['tmpsrc'], function () {
+ fs.writeFileSync('tmpsrc/dep1.c', 'src/src_1');
+ console.log('tmpsrc/dep1.c task');
+ }, {async: true});
+
+ rule('tmpbin/%.oo', 'tmpsrc/%.c', function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' ns task');
+ exec(cmd);
+ });
+});
+////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+// Chain rule
+// rule('tmpbin/%.pdf', 'tmpbin/%.dvi', function() { ...
+// rule('tmpbin/%.dvi', 'tmpsrc/%.tex', ['tmpbin'], function() { ...
+task('tmp_cr', [
+ 'chainrule:init'
+ , 'chainrule:tmpbin/file1.pdf'
+ , 'chainrule:tmpbin/file2.pdf' ], function () {
+ console.log('tmp chainrule namespace task');
+ let data1 = fs.readFileSync('tmpbin/file1.pdf');
+ let data2 = fs.readFileSync('tmpbin/file2.pdf');
+ fs.writeFileSync('tmp_cr', data1 + data2 + ' chainrule namespace');
+});
+
+namespace('chainrule', function () {
+ task('init', ['tmpsrc', 'tmpbin'], function () {
+ fs.writeFileSync('tmpsrc/file1.tex', 'tex1 ');
+ fs.writeFileSync('tmpsrc/file2.tex', 'tex2 ');
+ console.log('chainrule init task');
+ });
+
+ rule('tmpbin/%.pdf', 'tmpbin/%.dvi', function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' dvi->pdf task');
+ exec(cmd);
+ });
+
+ rule('tmpbin/%.dvi', 'tmpsrc/%.tex', ['tmpbin'], function () {
+ let cmd = util.format('cp %s %s', this.source, this.name);
+ console.log(cmd + ' tex->dvi task');
+ exec(cmd);
+ });
+});
+////////////////////////////////////////////////////////////
+namespace('precedence', function () {
+ task('test', ['foo.html'], function () {
+ console.log('ran test');
+ });
+
+ rule('.html', '.txt', function () {
+ console.log('created html');
+ let data = fs.readFileSync(this.source);
+ fs.writeFileSync(this.name, data.toString());
+ });
+});
+
+namespace('regexPattern', function () {
+ task('test', ['foo.html'], function () {
+ console.log('ran test');
+ });
+
+ rule(/\.html$/, '.txt', function () {
+ console.log('created html');
+ let data = fs.readFileSync(this.source);
+ fs.writeFileSync(this.name, data.toString());
+ });
+});
+
+namespace('sourceFunction', function () {
+
+ let srcFunc = function (taskName) {
+ return taskName.replace(/\.[^.]+$/, '.txt');
+ };
+
+ task('test', ['foo.html'], function () {
+ console.log('ran test');
+ });
+
+ rule('.html', srcFunc, function () {
+ console.log('created html');
+ let data = fs.readFileSync(this.source);
+ fs.writeFileSync(this.name, data.toString());
+ });
+});
+
+////////////////////////////////////////////////////////////
+task('clean', function () {
+ rmRf('./foo');
+ rmRf('./tmp');
+});
diff --git a/tools/ui/node_modules/jake/test/integration/list_tasks.js b/tools/ui/node_modules/jake/test/integration/list_tasks.js
new file mode 100644
index 0000000000000000000000000000000000000000..c21d030d88b453448c1170b05eedf19484f0a45c
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/list_tasks.js
@@ -0,0 +1,15 @@
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+let assert = require('assert');
+let proc = require('child_process');
+
+suite('listTasks', function () {
+ test('execute "jake -T" without any errors', function () {
+ let message = 'cannot run "jake -T" command';
+ let listTasks = function () {
+ proc.execFileSync(JAKE_CMD, ['-T']);
+ };
+ assert.doesNotThrow(listTasks, TypeError, message);
+ });
+});
diff --git a/tools/ui/node_modules/jake/test/integration/publish_task.js b/tools/ui/node_modules/jake/test/integration/publish_task.js
new file mode 100644
index 0000000000000000000000000000000000000000..a941b30c57a4f1b7a94bfbf8359f49131da38d95
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/publish_task.js
@@ -0,0 +1,27 @@
+let assert = require('assert');
+let exec = require('child_process').execSync;
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+suite('publishTask', function () {
+
+ this.timeout(7000);
+
+ test('default task', function () {
+ let out = exec(`${JAKE_CMD} -q publish`).toString().trim();
+ let expected = [
+ 'Fetched remote tags.'
+ , 'On branch v0.0'
+ , 'Bumped version number to v0.0.2.'
+ , 'Created package for zerb v0.0.2'
+ , 'Publishing zerb v0.0.2'
+ , './pkg/zerb-v0.0.2.tar.gz'
+ , 'BOOM! Published.'
+ , 'Cleaned up package'
+ ].join('\n');
+ assert.equal(expected, out);
+ });
+
+});
+
diff --git a/tools/ui/node_modules/jake/test/integration/rule.js b/tools/ui/node_modules/jake/test/integration/rule.js
new file mode 100644
index 0000000000000000000000000000000000000000..468db01344f25db3b2f8f8bcb38f56f02624adc3
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/rule.js
@@ -0,0 +1,217 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+let assert = require('assert');
+let exec = require('child_process').execSync;
+let fs = require('fs');
+let { Rule } = require(`${PROJECT_DIR}/lib/rule`);
+let { rmRf } = require(`${PROJECT_DIR}/lib/jake`);
+
+let cleanUpAndNext = function (callback) {
+ // Gotta add globbing to file utils rmRf
+ let tmpFiles = [
+ 'tmp'
+ , 'tmp_ns'
+ , 'tmp_cr'
+ , 'tmp_p'
+ , 'tmp_pf'
+ , 'tmpbin'
+ , 'tmpsrc'
+ , 'tmp_dep1.c'
+ , 'tmp_dep1.o'
+ , 'tmp_dep1.oo'
+ , 'tmp_dep2.c'
+ , 'tmp_dep2.o'
+ , 'tmp_dep2.oo'
+ , 'foo'
+ , 'foo.html'
+ ];
+ tmpFiles.forEach(function (f) {
+ rmRf(f, {
+ silent: true
+ });
+ });
+ callback && callback();
+};
+
+suite('rule', function () {
+
+ this.timeout(7000);
+
+ setup(function (next) {
+ cleanUpAndNext(next);
+ });
+
+
+ // - name foo:bin/main.o
+ // - pattern bin/%.o
+ // - source src/%.c
+ //
+ // return {
+ // 'dep' : 'foo:src/main.c',
+ // 'file': 'src/main.c'
+ // };
+ test('Rule.getSource', function () {
+ let src = Rule.getSource('foo:bin/main.o', 'bin/%.o', 'src/%.c');
+ assert.equal('foo:src/main.c', src);
+ });
+
+ test('rule w/o pattern', function () {
+ let out = exec( `${JAKE_CMD} -q tmp`).toString().trim();
+ let output = [
+ "tmp_dep2.c task"
+ , "tmp_dep1.c task"
+ , "cp tmp_dep1.c tmp_dep1.o task"
+ , "cp tmp_dep2.c tmp_dep2.o task"
+ , "tmp task"];
+ assert.equal( output.join('\n'), out);
+ let data = fs.readFileSync(process.cwd() + '/tmp');
+ assert.equal('src_1src_2', data.toString());
+ cleanUpAndNext();
+ });
+
+ test('rule w pattern w/o folder w/o namespace', function () {
+ let out = exec( `${JAKE_CMD} -q tmp_p`).toString().trim();
+ let output = [
+ "tmp_dep2.c task"
+ , "tmp_dep1.c task"
+ , "cp tmp_dep1.c tmp_dep1.oo task"
+ , "cp tmp_dep2.c tmp_dep2.oo task"
+ , "tmp pattern task"];
+ let data;
+ assert.equal( output.join('\n'), out);
+ data = fs.readFileSync(process.cwd() + '/tmp_p');
+ assert.equal('src_1src_2 pattern', data.toString());
+ cleanUpAndNext();
+ });
+
+ test('rule w pattern w folder w/o namespace', function () {
+ let out = exec( `${JAKE_CMD} -q tmp_pf`).toString().trim();
+ let output = [
+ "tmpsrc/tmp_dep1.c task"
+ , "cp tmpsrc/tmp_dep1.c tmpbin/tmp_dep1.oo task"
+ , "tmpsrc/tmp_dep2.c task"
+ , "cp tmpsrc/tmp_dep2.c tmpbin/tmp_dep2.oo task"
+ , "tmp pattern folder task"];
+ let data;
+ assert.equal( output.join('\n'), out);
+ data = fs.readFileSync(process.cwd() + '/tmp_pf');
+ assert.equal('src/src_1src/src_2 pattern folder', data.toString());
+ cleanUpAndNext();
+ });
+
+ test.skip('rule w pattern w folder w namespace', function () {
+ let out = exec( `${JAKE_CMD} -q tmp_ns`).toString().trim();
+ let output = [
+ "tmpsrc/file2.c init task" // yes
+ , "tmpsrc/tmp_dep2.c task" // no
+ , "cp tmpsrc/tmp_dep2.c tmpbin/tmp_dep2.oo task" // no
+ , "tmpsrc/dep1.c task" // no
+ , "cp tmpsrc/dep1.c tmpbin/dep1.oo ns task" // no
+ , "cp tmpsrc/file2.c tmpbin/file2.oo ns task" // yes
+ , "tmp pattern folder namespace task"]; // yes
+ let data;
+ assert.equal( output.join('\n'), out);
+ data = fs.readFileSync(process.cwd() + '/tmp_ns');
+ assert.equal('src/src_1src/src_2src/src_3 pattern folder namespace', data.toString());
+ cleanUpAndNext();
+ });
+
+ test.skip('rule w chain w pattern w folder w namespace', function () {
+ let out = exec( `${JAKE_CMD} -q tmp_cr`).toString().trim();
+ let output = [
+ "chainrule init task"
+ , "cp tmpsrc/file1.tex tmpbin/file1.dvi tex->dvi task"
+ , "cp tmpbin/file1.dvi tmpbin/file1.pdf dvi->pdf task"
+ , "cp tmpsrc/file2.tex tmpbin/file2.dvi tex->dvi task"
+ , "cp tmpbin/file2.dvi tmpbin/file2.pdf dvi->pdf task"
+ , "tmp chainrule namespace task"];
+ let data;
+ assert.equal( output.join('\n'), out);
+ data = fs.readFileSync(process.cwd() + '/tmp_cr');
+ assert.equal('tex1 tex2 chainrule namespace', data.toString());
+ cleanUpAndNext();
+ });
+
+
+ ['precedence', 'regexPattern', 'sourceFunction'].forEach(function (key) {
+
+ test('rule with source file not created yet (' + key + ')', function () {
+ let write = process.stderr.write;
+ process.stderr.write = () => {};
+ rmRf('foo.txt', {silent: true});
+ rmRf('foo.html', {silent: true});
+ try {
+ exec(`${JAKE_CMD} ` + key + ':test');
+ }
+ catch(err) {
+ // foo.txt prereq doesn't exist yet
+ assert.ok(err.message.indexOf('Unknown task "foo.html"') > -1);
+ }
+ process.stderr.write = write;
+ });
+
+ test('rule with source file now created (' + key + ')', function () {
+ fs.writeFileSync('foo.txt', '');
+ let out = exec(`${JAKE_CMD} -q ` + key + ':test').toString().trim();
+ // Should run prereq and test task
+ let output = [
+ 'created html'
+ , 'ran test'
+ ];
+ assert.equal(output.join('\n'), out);
+ });
+
+ test('rule with source file modified (' + key + ')', function (next) {
+ setTimeout(function () {
+ fs.writeFileSync('foo.txt', '');
+ let out = exec(`${JAKE_CMD} -q ` + key + ':test').toString().trim();
+ // Should again run both prereq and test task
+ let output = [
+ 'created html'
+ , 'ran test'
+ ];
+ assert.equal(output.join('\n'), out);
+ //next();
+ cleanUpAndNext(next);
+ }, 1000); // Wait to do the touch to ensure mod-time is different
+ });
+
+ test('rule with existing objective file and no source ' +
+ ' (should be normal file-task) (' + key + ')', function () {
+ // Remove just the source file
+ fs.writeFileSync('foo.html', '');
+ rmRf('foo.txt', {silent: true});
+ let out = exec(`${JAKE_CMD} -q ` + key + ':test').toString().trim();
+ // Should treat existing objective file as plain file-task,
+ // and just run test-task
+ let output = [
+ 'ran test'
+ ];
+ assert.equal(output.join('\n'), out);
+ cleanUpAndNext();
+ });
+
+ });
+
+});
+
+
diff --git a/tools/ui/node_modules/jake/test/integration/selfdep.js b/tools/ui/node_modules/jake/test/integration/selfdep.js
new file mode 100644
index 0000000000000000000000000000000000000000..3195d08c9284488013a3bf1c2781c4ba28ecfbbc
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/selfdep.js
@@ -0,0 +1,42 @@
+let assert = require('assert');
+let exec = require('child_process').execSync;
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+suite('selfDep', function () {
+
+ this.timeout(7000);
+
+ let origStderrWrite;
+
+ setup(function () {
+ origStderrWrite = process.stderr.write;
+ process.stderr.write = function () {};
+ });
+
+ teardown(function () {
+ process.stderr.write = origStderrWrite;
+ });
+
+ test('self dep const', function () {
+ try {
+ exec(`${JAKE_CMD} selfdepconst`);
+ }
+ catch(e) {
+ assert(e.message.indexOf('dependency of itself') > -1);
+ }
+ });
+
+ test('self dep dyn', function () {
+ try {
+ exec(`${JAKE_CMD} selfdepdyn`);
+ }
+ catch(e) {
+ assert(e.message.indexOf('dependency of itself') > -1);
+ }
+ });
+
+});
+
+
diff --git a/tools/ui/node_modules/jake/test/integration/task_base.js b/tools/ui/node_modules/jake/test/integration/task_base.js
new file mode 100644
index 0000000000000000000000000000000000000000..9aa501d7d5519bab5f1a4cfb1f0795d16685384c
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/integration/task_base.js
@@ -0,0 +1,167 @@
+let assert = require('assert');
+let h = require('./helpers');
+let exec = require('child_process').execSync;
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+const JAKE_CMD = `${PROJECT_DIR}/bin/cli.js`;
+
+suite('taskBase', function () {
+
+ this.timeout(7000);
+
+ test('default task', function () {
+ let out;
+ out = exec(`${JAKE_CMD} -q`).toString().trim();
+ assert.equal(out, 'default task');
+ out = exec(`${JAKE_CMD} -q default`).toString().trim();
+ assert.equal(out, 'default task');
+ });
+
+ test('task with no action', function () {
+ let out = exec(`${JAKE_CMD} -q noAction`).toString().trim();
+ assert.equal(out, 'default task');
+ });
+
+ test('a task with no action and no prereqs', function () {
+ exec(`${JAKE_CMD} noActionNoPrereqs`);
+ });
+
+ test('a task that exists at the top-level, and not in the specified namespace, should error', function () {
+ let res = require('child_process').spawnSync(`${JAKE_CMD}`,
+ ['asdfasdfasdf:zerbofrangazoomy']);
+ let err = res.stderr.toString();
+ assert.ok(err.indexOf('Unknown task' > -1));
+ });
+
+ test('passing args to a task', function () {
+ let out = exec(`${JAKE_CMD} -q argsEnvVars[foo,bar]`).toString().trim();
+ let parsed = h.parse(out);
+ let args = parsed.args;
+ assert.equal(args[0], 'foo');
+ assert.equal(args[1], 'bar');
+ });
+
+ test('a task with environment vars', function () {
+ let out = exec(`${JAKE_CMD} -q argsEnvVars foo=bar baz=qux`).toString().trim();
+ let parsed = h.parse(out);
+ let env = parsed.env;
+ assert.equal(env.foo, 'bar');
+ assert.equal(env.baz, 'qux');
+ });
+
+ test('passing args and using environment vars', function () {
+ let out = exec(`${JAKE_CMD} -q argsEnvVars[foo,bar] foo=bar baz=qux`).toString().trim();
+ let parsed = h.parse(out);
+ let args = parsed.args;
+ let env = parsed.env;
+ assert.equal(args[0], 'foo');
+ assert.equal(args[1], 'bar');
+ assert.equal(env.foo, 'bar');
+ assert.equal(env.baz, 'qux');
+ });
+
+ test('a simple prereq', function () {
+ let out = exec(`${JAKE_CMD} -q foo:baz`).toString().trim();
+ assert.equal(out, 'foo:bar task\nfoo:baz task');
+ });
+
+ test('a duplicate prereq only runs once', function () {
+ let out = exec(`${JAKE_CMD} -q foo:asdf`).toString().trim();
+ assert.equal(out, 'foo:bar task\nfoo:baz task\nfoo:asdf task');
+ });
+
+ test('a prereq with command-line args', function () {
+ let out = exec(`${JAKE_CMD} -q foo:qux`).toString().trim();
+ assert.equal(out, 'foo:bar[asdf,qwer] task\nfoo:qux task');
+ });
+
+ test('a prereq with args via invoke', function () {
+ let out = exec(`${JAKE_CMD} -q foo:frang[zxcv,uiop]`).toString().trim();
+ assert.equal(out, 'foo:bar[zxcv,uiop] task\nfoo:frang task');
+ });
+
+ test('a prereq with args via execute', function () {
+ let out = exec(`${JAKE_CMD} -q foo:zerb[zxcv,uiop]`).toString().trim();
+ assert.equal(out, 'foo:bar[zxcv,uiop] task\nfoo:zerb task');
+ });
+
+ test('repeating the task via execute', function () {
+ let out = exec(`${JAKE_CMD} -q foo:voom`).toString().trim();
+ assert.equal(out, 'foo:bar task\nfoo:bar task\ncomplete\ncomplete');
+ });
+
+ test('prereq execution-order', function () {
+ let out = exec(`${JAKE_CMD} -q hoge:fuga`).toString().trim();
+ assert.equal(out, 'hoge:hoge task\nhoge:piyo task\nhoge:fuga task');
+ });
+
+ test('basic async task', function () {
+ let out = exec(`${JAKE_CMD} -q bar:bar`).toString().trim();
+ assert.equal(out, 'bar:foo task\nbar:bar task');
+ });
+
+ test('promise async task', function () {
+ let out = exec(`${JAKE_CMD} -q bar:dependOnpromise`).toString().trim();
+ assert.equal(out, 'bar:promise task\nbar:dependOnpromise task saw value 123654');
+ });
+
+ test('failing promise async task', function () {
+ try {
+ exec(`${JAKE_CMD} -q bar:brokenPromise`);
+ }
+ catch(e) {
+ assert(e.message.indexOf('Command failed') > -1);
+ }
+ });
+
+ test('that current-prereq index gets reset', function () {
+ let out = exec(`${JAKE_CMD} -q hoge:kira`).toString().trim();
+ assert.equal(out, 'hoge:hoge task\nhoge:piyo task\nhoge:fuga task\n' +
+ 'hoge:charan task\nhoge:gero task\nhoge:kira task');
+ });
+
+ test('modifying a task by adding prereq during execution', function () {
+ let out = exec(`${JAKE_CMD} -q voom`).toString().trim();
+ assert.equal(out, 2);
+ });
+
+ test('listening for task error-event', function () {
+ try {
+ exec(`${JAKE_CMD} -q vronk:groo`).toString().trim();
+ }
+ catch(e) {
+ assert(e.message.indexOf('OMFGZONG') > -1);
+ }
+ });
+
+ test('listening for jake error-event', function () {
+ let out = exec(`${JAKE_CMD} -q throwy`).toString().trim();
+ assert(out.indexOf('Emitted\nError: I am bad') > -1);
+ });
+
+ test('listening for jake unhandledRejection-event', function () {
+ let out = exec(`${JAKE_CMD} -q promiseRejecter`).toString().trim();
+ assert.equal(out, '');
+ });
+
+ test('large number of same prereqs', function () {
+ let out = exec(`${JAKE_CMD} -q large:same`).toString().trim();
+ assert.equal(out, 'large:leaf\nlarge:same');
+ });
+
+ test('large number of different prereqs', function () {
+ let out = exec(`${JAKE_CMD} -q large:different`).toString().trim();
+ assert.equal(out, 'leaf-12\nleaf-123\nlarge:different');
+ });
+
+ test('large number of different prereqs', function () {
+ let out = exec(`${JAKE_CMD} -q usingRequire:test`).toString().trim();
+ assert.equal(out, 'howdy test');
+ });
+
+ test('modifying a namespace by adding a new task', function () {
+ let out = exec(`${JAKE_CMD} -q one:two`).toString().trim();
+ assert.equal('one:one\none:two', out);
+ });
+
+});
diff --git a/tools/ui/node_modules/jake/test/unit/jakefile.js b/tools/ui/node_modules/jake/test/unit/jakefile.js
new file mode 100644
index 0000000000000000000000000000000000000000..89ff52331dd9b9305797ee338153f500558df129
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/unit/jakefile.js
@@ -0,0 +1,36 @@
+
+task('foo', function () {
+ console.log('ran top-level foo');
+});
+
+task('bar', function () {
+ console.log('ran top-level bar');
+});
+
+task('zerb', function () {
+ console.log('ran zerb');
+});
+
+namespace('zooby', function () {
+ task('zerp', function () {});
+
+ task('derp', ['zerp'], function () {});
+
+ namespace('frang', function () {
+
+ namespace('w00t', function () {
+ task('bar', function () {
+ console.log('ran zooby:frang:w00t:bar');
+ });
+ });
+
+ task('asdf', function () {});
+ });
+
+});
+
+namespace('hurr', function () {
+ namespace('durr');
+});
+
+
diff --git a/tools/ui/node_modules/jake/test/unit/namespace.js b/tools/ui/node_modules/jake/test/unit/namespace.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6b3ff56af5da837bfe325ceb85debc5a389f073
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/unit/namespace.js
@@ -0,0 +1,77 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+
+// Load the jake global
+require(`${PROJECT_DIR}/lib/jake`);
+let { Namespace } = require(`${PROJECT_DIR}/lib/namespace`);
+
+require('./jakefile');
+
+let assert = require('assert');
+
+suite('namespace', function () {
+
+ this.timeout(7000);
+
+ test('resolve namespace by relative name', function () {
+ let aaa, bbb, ccc;
+ aaa = namespace('aaa', function () {
+ bbb = namespace('bbb', function () {
+ ccc = namespace('ccc', function () {
+ });
+ });
+ });
+
+ assert.ok(aaa, Namespace.ROOT_NAMESPACE.resolveNamespace('aaa'));
+ assert.ok(bbb === aaa.resolveNamespace('bbb'));
+ assert.ok(ccc === aaa.resolveNamespace('bbb:ccc'));
+ });
+
+ test('resolve task in sub-namespace by relative path', function () {
+ let curr = Namespace.ROOT_NAMESPACE.resolveNamespace('zooby');
+ let task = curr.resolveTask('frang:w00t:bar');
+ assert.ok(task.action.toString().indexOf('zooby:frang:w00t:bar') > -1);
+ });
+
+ test('prefer local to top-level', function () {
+ let curr = Namespace.ROOT_NAMESPACE.resolveNamespace('zooby:frang:w00t');
+ let task = curr.resolveTask('bar');
+ assert.ok(task.action.toString().indexOf('zooby:frang:w00t:bar') > -1);
+ });
+
+ test('does resolve top-level', function () {
+ let curr = Namespace.ROOT_NAMESPACE.resolveNamespace('zooby:frang:w00t');
+ let task = curr.resolveTask('foo');
+ assert.ok(task.action.toString().indexOf('top-level foo') > -1);
+ });
+
+ test('absolute lookup works from sub-namespaces', function () {
+ let curr = Namespace.ROOT_NAMESPACE.resolveNamespace('hurr:durr');
+ let task = curr.resolveTask('zooby:frang:w00t:bar');
+ assert.ok(task.action.toString().indexOf('zooby:frang:w00t:bar') > -1);
+ });
+
+ test('resolution miss with throw error', function () {
+ let curr = Namespace.ROOT_NAMESPACE;
+ let task = curr.resolveTask('asdf:qwer');
+ assert.ok(!task);
+ });
+
+});
diff --git a/tools/ui/node_modules/jake/test/unit/parseargs.js b/tools/ui/node_modules/jake/test/unit/parseargs.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a3ddd5ad10edee3ce2f34a36a9fb9e54f7e35e5
--- /dev/null
+++ b/tools/ui/node_modules/jake/test/unit/parseargs.js
@@ -0,0 +1,169 @@
+/*
+ * Jake JavaScript build tool
+ * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+*/
+
+const PROJECT_DIR = process.env.PROJECT_DIR;
+
+let parseargs = require(`${PROJECT_DIR}/lib/parseargs`);
+let assert = require('assert');
+let optsReg = [
+ { full: 'directory',
+ abbr: 'C',
+ preempts: false,
+ expectValue: true
+ },
+ { full: 'jakefile',
+ abbr: 'f',
+ preempts: false,
+ expectValue: true
+ },
+ { full: 'tasks',
+ abbr: 'T',
+ preempts: true
+ },
+ { full: 'tasks',
+ abbr: 'ls',
+ preempts: true
+ },
+ { full: 'trace',
+ abbr: 't',
+ preempts: false,
+ expectValue: false
+ },
+ { full: 'help',
+ abbr: 'h',
+ preempts: true
+ },
+ { full: 'version',
+ abbr: 'V',
+ preempts: true
+ }
+];
+let p = new parseargs.Parser(optsReg);
+let z = function (s) { return s.split(' '); };
+let res;
+
+suite('parseargs', function () {
+
+ test('long preemptive opt and val with equal-sign, ignore further opts', function () {
+ res = p.parse(z('--tasks=foo --jakefile=asdf'));
+ assert.equal('foo', res.opts.tasks);
+ assert.equal(undefined, res.opts.jakefile);
+ });
+
+ test('long preemptive opt and val without equal-sign, ignore further opts', function () {
+ res = p.parse(z('--tasks foo --jakefile=asdf'));
+ assert.equal('foo', res.opts.tasks);
+ assert.equal(undefined, res.opts.jakefile);
+ });
+
+ test('long preemptive opt and no val, ignore further opts', function () {
+ res = p.parse(z('--tasks --jakefile=asdf'));
+ assert.equal(true, res.opts.tasks);
+ assert.equal(undefined, res.opts.jakefile);
+ });
+
+ test('preemptive opt with no val, should be true', function () {
+ res = p.parse(z('-T'));
+ assert.equal(true, res.opts.tasks);
+ });
+
+ test('preemptive opt with no val, should be true and ignore further opts', function () {
+ res = p.parse(z('-T -f'));
+ assert.equal(true, res.opts.tasks);
+ assert.equal(undefined, res.opts.jakefile);
+ });
+
+ test('preemptive opt with val, should be val', function () {
+ res = p.parse(z('-T zoobie -f foo/bar/baz'));
+ assert.equal('zoobie', res.opts.tasks);
+ assert.equal(undefined, res.opts.jakefile);
+ });
+
+ test('-f expects a value, -t does not (howdy is task-name)', function () {
+ res = p.parse(z('-f zoobie -t howdy'));
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal(true, res.opts.trace);
+ assert.equal('howdy', res.taskNames[0]);
+ });
+
+ test('different order, -f expects a value, -t does not (howdy is task-name)', function () {
+ res = p.parse(z('-f zoobie howdy -t'));
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal(true, res.opts.trace);
+ assert.equal('howdy', res.taskNames[0]);
+ });
+
+ test('-f expects a value, -t does not (foo=bar is env var)', function () {
+ res = p.parse(z('-f zoobie -t foo=bar'));
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal(true, res.opts.trace);
+ assert.equal('bar', res.envVars.foo);
+ assert.equal(undefined, res.taskNames[0]);
+ });
+
+ test('-f expects a value, -t does not (foo=bar is env-var, task-name follows)', function () {
+ res = p.parse(z('-f zoobie -t howdy foo=bar'));
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal(true, res.opts.trace);
+ assert.equal('bar', res.envVars.foo);
+ assert.equal('howdy', res.taskNames[0]);
+ });
+
+ test('-t does not expect a value, -f does (howdy is task-name)', function () {
+ res = p.parse(z('-t howdy -f zoobie'));
+ assert.equal(true, res.opts.trace);
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal('howdy', res.taskNames[0]);
+ });
+
+ test('--trace does not expect a value, -f does (howdy is task-name)', function () {
+ res = p.parse(z('--trace howdy --jakefile zoobie'));
+ assert.equal(true, res.opts.trace);
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal('howdy', res.taskNames[0]);
+ });
+
+ test('--trace does not expect a value (equal), -f does (throw howdy away)', function () {
+ res = p.parse(z('--trace=howdy --jakefile=zoobie'));
+ assert.equal(true, res.opts.trace);
+ assert.equal('zoobie', res.opts.jakefile);
+ assert.equal(undefined, res.taskNames[0]);
+ });
+
+ /*
+, test('task-name with positional args', function () {
+ res = p.parse(z('foo:bar[asdf,qwer]'));
+ assert.equal('asdf', p.taskArgs[0]);
+ assert.equal('qwer', p.taskArgs[1]);
+ }
+
+, test('opts, env vars, task-name with positional args', function () {
+ res = p.parse(z('-f ./tests/Jakefile -t default[asdf,qwer] foo=bar'));
+ assert.equal('./tests/Jakefile', res.opts.jakefile);
+ assert.equal(true, res.opts.trace);
+ assert.equal('bar', res.envVars.foo);
+ assert.equal('default', res.taskName);
+ assert.equal('asdf', p.taskArgs[0]);
+ assert.equal('qwer', p.taskArgs[1]);
+ }
+*/
+
+
+});
+
+
diff --git a/tools/ui/node_modules/jake/usage.txt b/tools/ui/node_modules/jake/usage.txt
new file mode 100644
index 0000000000000000000000000000000000000000..40395c5a5bfba635edcb8ec522a5cfdf899cc893
--- /dev/null
+++ b/tools/ui/node_modules/jake/usage.txt
@@ -0,0 +1,17 @@
+Jake JavaScript build tool
+********************************************************************************
+If no flags are given, Jake looks for a Jakefile or Jakefile.js in the current directory.
+********************************************************************************
+{Usage}: jake [options ...] [env variables ...] target
+
+{Options}:
+ -f, --jakefile FILE Use FILE as the Jakefile.
+ -C, --directory DIRECTORY Change to DIRECTORY before running tasks.
+ -q, --quiet Do not log messages to standard output.
+ -B, --always-make Unconditionally make all targets.
+ -T/-ls, --tasks Display the tasks (matching optional PATTERN) with descriptions, then exit.
+ -J, --jakelibdir JAKELIBDIR Auto-import any .jake files in JAKELIBDIR. (default is \'jakelib\')
+ -h, --help Display this help message.
+ -V/-v, --version Display the Jake version.
+ -ar, --allow-rejection Keep running even after unhandled promise rejection.
+
diff --git a/tools/ui/node_modules/jiti/LICENSE b/tools/ui/node_modules/jiti/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..e739abce461d8b2899aaec6529a4af24a417e0fc
--- /dev/null
+++ b/tools/ui/node_modules/jiti/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tools/ui/node_modules/jiti/README.md b/tools/ui/node_modules/jiti/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b3af4838b8a4e583c266a318422aa5755065d862
--- /dev/null
+++ b/tools/ui/node_modules/jiti/README.md
@@ -0,0 +1,258 @@
+# jiti
+
+
+
+[](https://npmjs.com/package/jiti)
+[](https://npmjs.com/package/jiti)
+[](https://bundlephobia.com/package/jiti)
+
+
+
+> This is the active development branch. Check out [jiti/v1](https://github.com/unjs/jiti/tree/v1) for legacy v1 docs and code.
+
+## 🌟 Used in
+
+[Docusaurus](https://docusaurus.io/), [ESLint](https://github.com/eslint/eslint), [FormKit](https://formkit.com/), [Histoire](https://histoire.dev/), [Knip](https://knip.dev/), [Nitro](https://nitro.unjs.io/), [Nuxt](https://nuxt.com/), [PostCSS loader](https://github.com/webpack-contrib/postcss-loader), [Rsbuild](https://rsbuild.dev/), [Size Limit](https://github.com/ai/size-limit), [Slidev](https://sli.dev/), [Tailwindcss](https://tailwindcss.com/), [Tokenami](https://github.com/tokenami/tokenami), [UnoCSS](https://unocss.dev/), [WXT](https://wxt.dev/), [Winglang](https://www.winglang.io/), [Graphql code generator](https://the-guild.dev/graphql/codegen), [Lingui](https://lingui.dev/), [Scaffdog](https://scaff.dog/), [Storybook](https://storybook.js.org), [...UnJS ecosystem](https://unjs.io/), [...60M+ npm monthly downloads](https://npm.chart.dev/jiti), [...6M+ public repositories](https://github.com/unjs/jiti/network/dependents).
+
+## ✅ Features
+
+- Seamless TypeScript and ESM syntax support for Node.js
+- Seamless interoperability between ESM and CommonJS
+- Asynchronous API to replace `import()`
+- Synchronous API to replace `require()` (deprecated)
+- Super slim and zero dependency
+- Custom resolve aliases
+- Smart syntax detection to avoid extra transforms
+- Node.js native `require.cache` integration
+- Filesystem transpile with hard disk caches
+- ESM Loader support
+- JSX support (opt-in)
+
+> [!IMPORTANT]
+> To enhance compatibility, jiti `>=2.1` enabled [`interopDefault`](#interopdefault) using a new Proxy method. If you migrated to `2.0.0` earlier, this might have caused behavior changes. In case of any issues during the upgrade, please [report](https://github.com/unjs/jiti/issues) so we can investigate to solve them. 🙏🏼
+
+## 💡 Usage
+
+### CLI
+
+You can use `jiti` CLI to quickly run any script with TypeScript and native ESM support!
+
+```bash
+npx jiti ./index.ts
+```
+
+### Programmatic
+
+Initialize a jiti instance:
+
+```js
+// ESM
+import { createJiti } from "jiti";
+const jiti = createJiti(import.meta.url);
+
+// CommonJS (deprecated)
+const { createJiti } = require("jiti");
+const jiti = createJiti(__filename);
+```
+
+Import (async) and resolve with ESM compatibility:
+
+```js
+// jiti.import(id) is similar to import(id)
+const mod = await jiti.import("./path/to/file.ts");
+
+// jiti.esmResolve(id) is similar to import.meta.resolve(id)
+const resolvedPath = jiti.esmResolve("./src");
+```
+
+If you need the default export of module, you can use `jiti.import(id, { default: true })` as shortcut to `mod?.default ?? mod`.
+
+```js
+// shortcut to mod?.default ?? mod
+const modDefault = await jiti.import("./path/to/file.ts", { default: true });
+```
+
+CommonJS (sync & deprecated):
+
+```js
+// jiti() is similar to require(id)
+const mod = jiti("./path/to/file.ts");
+
+// jiti.resolve() is similar to require.resolve(id)
+const resolvedPath = jiti.resolve("./src");
+```
+
+You can also pass options as the second argument:
+
+```js
+const jiti = createJiti(import.meta.url, { debug: true });
+```
+
+### Register global ESM loader
+
+You can globally register jiti using [global hooks](https://nodejs.org/api/module.html#initialize). (Important: Requires Node.js > 20)
+
+```js
+import "jiti/register";
+```
+
+Or:
+
+```bash
+node --import jiti/register index.ts
+```
+
+## 🎈 `jiti/native`
+
+You can alias `jiti` to `jiti/native` to directly depend on runtime's [`import.meta.resolve`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta/resolve) and dynamic [`import()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) support. This allows easing up the ecosystem transition to runtime native support by giving the same API of jiti.
+
+## ⚙️ Options
+
+### `debug`
+
+- Type: Boolean
+- Default: `false`
+- Environment variable: `JITI_DEBUG`
+
+Enable verbose logging. You can use `JITI_DEBUG=1 ` to enable it.
+
+### `fsCache`
+
+- Type: Boolean | String
+- Default: `true`
+- Environment variable: `JITI_FS_CACHE`
+
+Filesystem source cache (enabled by default)
+
+By default (when is `true`), jiti uses `node_modules/.cache/jiti` (if exists) or `{TMP_DIR}/jiti`.
+
+**Note:** It is recommended that this option be enabled for better performance.
+
+### `rebuildFsCache`
+
+- Type: Boolean
+- Default: `false`
+- Environment variable: `JITI_REBUILD_FS_CACHE`
+
+Rebuild filesystem source cache created by `fsCache`.
+
+### `moduleCache`
+
+- Type: String
+- Default: `true`
+- Environment variable: `JITI_MODULE_CACHE`
+
+Runtime module cache (enabled by default).
+
+Disabling allows editing code and importing the same module multiple times.
+
+When enabled, jiti integrates with Node.js native CommonJS cache-store.
+
+### `transform`
+
+- Type: Function
+- Default: Babel (lazy loaded)
+
+Transform function. See [src/babel](./src/babel.ts) for more details
+
+### `sourceMaps`
+
+- Type: Boolean
+- Default `false`
+- Environment variable: `JITI_SOURCE_MAPS`
+
+Add inline source map to transformed source for better debugging.
+
+### `interopDefault`
+
+- Type: Boolean
+- Default: `true`
+- Environment variable: `JITI_INTEROP_DEFAULT`
+
+Jiti combines module exports with the `default` export using an internal Proxy to improve compatibility with mixed CJS/ESM usage. You can check the current implementation [here](https://github.com/unjs/jiti/blob/main/src/utils.ts#L105).
+
+> [!WARNING]
+> This option wraps **all imported modules** in a Proxy, which adds ~25-50ns overhead per property access. For performance-critical hot paths where you access module exports very frequently, consider setting `interopDefault: false` or `JITI_INTEROP_DEFAULT=false`.
+
+### `alias`
+
+- Type: Object
+- Default: -
+- Environment variable: `JITI_ALIAS`
+
+You can also pass an object to the environment variable for inline config. Example: `JITI_ALIAS='{"~/*": "./src/*"}' jiti ...`.
+
+Custom alias map used to resolve IDs.
+
+### `tsconfigPaths`
+
+- Type: Boolean | String
+- Default: `false`
+- Environment variable: `JITI_TSCONFIG_PATHS`
+
+Enable TypeScript [`paths`](https://www.typescriptlang.org/tsconfig/#paths) resolution using [`get-tsconfig`](https://github.com/privatenumber/get-tsconfig).
+
+- `true`: Auto-discover `tsconfig.json` by walking up from the jiti instance's parent path.
+- `string`: Explicit path to a `tsconfig.json` file.
+- `false` (default): Disabled.
+
+### `nativeModules`
+
+- Type: Array
+- Default: ['typescript']
+- Environment variable: `JITI_NATIVE_MODULES`
+
+List of modules (within `node_modules`) to always use native `require()` for them.
+
+### `transformModules`
+
+- Type: Array
+- Default: []
+- Environment variable: `JITI_TRANSFORM_MODULES`
+
+List of modules (within `node_modules`) to transform them regardless of syntax.
+
+### `importMeta`
+
+Parent module's [`import.meta`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta) context to use for ESM resolution. (only used for `jiti/native` import).
+
+### `tryNative`
+
+- Type: Boolean
+- Default: Enabled if bun is detected
+- Environment variable: `JITI_TRY_NATIVE`
+
+Try to use native require and import without jiti transformations first.
+
+### `jsx`
+
+- Type: Boolean | {options}
+- Default: `false`
+- Environment Variable: `JITI_JSX`
+
+Enable JSX support using [`@babel/plugin-transform-react-jsx`](https://babeljs.io/docs/babel-plugin-transform-react-jsx).
+
+See [`test/fixtures/jsx`](./test/fixtures/jsx) for framework integration examples.
+
+## Development
+
+- Clone this repository
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run `pnpm dev`
+- Run `pnpm jiti ./test/path/to/file.ts`
+
+## License
+
+
+
+Published under the [MIT](https://github.com/unjs/jiti/blob/main/LICENSE) license.
+Made by [@pi0](https://github.com/pi0) and [community](https://github.com/unjs/jiti/graphs/contributors) 💛
+
+
+
+
+
+
+
+
diff --git a/tools/ui/node_modules/jiti/dist/babel.cjs b/tools/ui/node_modules/jiti/dist/babel.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..1e6b684f9f1586231c56a19aaebeacccda2aad4d
--- /dev/null
+++ b/tools/ui/node_modules/jiti/dist/babel.cjs
@@ -0,0 +1,257 @@
+(()=>{var e={"./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files lazy recursive"(e){function webpackEmptyAsyncContext(e){return Promise.resolve().then(function(){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t})}webpackEmptyAsyncContext.keys=()=>[],webpackEmptyAsyncContext.resolve=webpackEmptyAsyncContext,webpackEmptyAsyncContext.id="./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files lazy recursive",e.exports=webpackEmptyAsyncContext},"./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files sync recursive"(e){function webpackEmptyContext(e){var t=new Error("Cannot find module '"+e+"'");throw t.code="MODULE_NOT_FOUND",t}webpackEmptyContext.keys=()=>[],webpackEmptyContext.resolve=webpackEmptyContext,webpackEmptyContext.id="./node_modules/.pnpm/@babel+core@7.29.0/node_modules/@babel/core/lib/config/files sync recursive",e.exports=webpackEmptyContext},"./node_modules/.pnpm/@babel+plugin-syntax-class-properties@7.12.13_@babel+core@7.29.0/node_modules/@babel/plugin-syntax-class-properties/lib/index.js"(e,t,r){"use strict";t.A=void 0;var n=(0,r("./node_modules/.pnpm/@babel+helper-plugin-utils@7.28.6/node_modules/@babel/helper-plugin-utils/lib/index.js").declare)(e=>(e.assertVersion(7),{name:"syntax-class-properties",manipulateOptions(e,t){t.plugins.push("classProperties","classPrivateProperties","classPrivateMethods")}}));t.A=n},"./node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"(e,t,r){var n;!function(e,t,r){"use strict";var n=Object.create,s=Object.defineProperty,i=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,a=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,__commonJS=(e,t)=>function(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/sourcemap-codec"(e,r){r.exports=t}}),c=__commonJS({"umd:@jridgewell/trace-mapping"(e,t){t.exports=r}}),u={};__export(u,{GenMapping:()=>E,addMapping:()=>addMapping,addSegment:()=>addSegment,allMappings:()=>allMappings,fromMap:()=>fromMap,maybeAddMapping:()=>maybeAddMapping,maybeAddSegment:()=>maybeAddSegment,setIgnore:()=>setIgnore,setSourceContent:()=>setSourceContent,toDecodedMap:()=>toDecodedMap,toEncodedMap:()=>toEncodedMap}),e.exports=__toCommonJS(u);var d=class{constructor(){this._indexes={__proto__:null},this.array=[]}};function cast(e){return e}function get(e,t){return cast(e)._indexes[t]}function put(e,t){const r=get(e,t);if(void 0!==r)return r;const{array:n,_indexes:s}=cast(e),i=n.push(t);return s[t]=i-1}function remove(e,t){const r=get(e,t);if(void 0===r)return;const{array:n,_indexes:s}=cast(e);for(let e=r+1;eaddSegmentInternal(!0,e,t,r,n,s,i,o,a),maybeAddMapping=(e,t)=>addMappingInternal(!0,e,t);function setSourceContent(e,t,r){const{_sources:n,_sourcesContent:s}=cast2(e);s[put(n,t)]=r}function setIgnore(e,t,r=!0){const{_sources:n,_sourcesContent:s,_ignoreList:i}=cast2(e),o=put(n,t);o===s.length&&(s[o]=null),r?put(i,o):remove(i,o)}function toDecodedMap(e){const{_mappings:t,_sources:r,_sourcesContent:n,_names:s,_ignoreList:i}=cast2(e);return removeEmptyFinalLines(t),{version:3,file:e.file||void 0,names:s.array,sourceRoot:e.sourceRoot||void 0,sources:r.array,sourcesContent:n,mappings:t,ignoreList:i.array}}function toEncodedMap(e){const t=toDecodedMap(e);return Object.assign({},t,{mappings:(0,h.encode)(t.mappings)})}function fromMap(e){const t=new m.TraceMap(e),r=new E({file:t.file,sourceRoot:t.sourceRoot});return putAll(cast2(r)._names,t.names),putAll(cast2(r)._sources,t.sources),cast2(r)._sourcesContent=t.sourcesContent||t.sources.map(()=>null),cast2(r)._mappings=(0,m.decodedMappings)(t),t.ignoreList&&putAll(cast2(r)._ignoreList,t.ignoreList),r}function allMappings(e){const t=[],{_mappings:r,_sources:n,_names:s}=cast2(e);for(let e=0;e=0&&!(t>=e[n][f]);r=n--);return r}function insert(e,t,r){for(let r=e.length;r>t;r--)e[r]=e[r-1];e[t]=r}function removeEmptyFinalLines(e){const{length:t}=e;let r=t;for(let t=r-1;t>=0&&!(e[t].length>0);r=t,t--);rfunction(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/trace-mapping"(e,t){t.exports=r}}),c=__commonJS({"umd:@jridgewell/gen-mapping"(e,r){r.exports=t}}),u={};__export(u,{default:()=>remapping}),e.exports=__toCommonJS(u);var d=__toESM(p()),h=__toESM(c()),m=__toESM(p()),f=SegmentObject("",-1,-1,"",null,!1),y=[];function SegmentObject(e,t,r,n,s,i){return{source:e,line:t,column:r,name:n,content:s,ignore:i}}function Source(e,t,r,n,s){return{map:e,sources:t,source:r,content:n,ignore:s}}function MapSource(e,t){return Source(e,t,"",null,!1)}function OriginalSource(e,t,r){return Source(null,y,e,t,r)}function traceMappings(e){const t=new h.GenMapping({file:e.map.file}),{sources:r,map:n}=e,s=n.names,i=(0,m.decodedMappings)(n);for(let e=0;enew d.TraceMap(e,"")),n=r.pop();for(let e=0;e1)throw new Error(`Transformation map ${e} must have exactly one source file.\nDid you specify these with the most recent transformation maps first?`);let s=build(n,t,"",0);for(let e=r.length-1;e>=0;e--)s=MapSource(r[e],[s]);return s}function build(e,t,r,n){const{resolvedSources:s,sourcesContent:i,ignoreList:o}=e,a=n+1;return MapSource(e,s.map((e,n)=>{const s={importer:r,depth:a,source:e||"",content:void 0,ignore:void 0},l=t(s.source,s),{source:p,content:c,ignore:u}=s;return l?build(new d.TraceMap(l,p),t,p,a):OriginalSource(p,void 0!==c?c:i?i[n]:null,void 0!==u?u:!!o&&o.includes(n))}))}var b=__toESM(c()),g=class{constructor(e,t){const r=t.decodedMappings?(0,b.toDecodedMap)(e):(0,b.toEncodedMap)(e);this.version=r.version,this.file=r.file,this.mappings=r.mappings,this.names=r.names,this.ignoreList=r.ignoreList,this.sourceRoot=r.sourceRoot,this.sources=r.sources,t.excludeContent||(this.sourcesContent=r.sourcesContent)}toString(){return JSON.stringify(this)}};function remapping(e,t,r){const n="object"==typeof r?r:{excludeContent:!!r,decodedMappings:!1},s=buildSourceMapTree(e,t);return new g(traceMappings(s),n)}}(e=r.nmd(e),r("./node_modules/.pnpm/@jridgewell+gen-mapping@0.3.13/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"),r("./node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js")),e.exports="default"in(n=e).exports?n.exports.default:n.exports},"./node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(e){e.exports=function(){"use strict";const e=/^[\w+.-]+:\/\//,t=/^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/,r=/^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;function isAbsoluteUrl(t){return e.test(t)}function isSchemeRelativeUrl(e){return e.startsWith("//")}function isAbsolutePath(e){return e.startsWith("/")}function isFileUrl(e){return e.startsWith("file:")}function isRelative(e){return/^[.?#]/.test(e)}function parseAbsoluteUrl(e){const r=t.exec(e);return makeUrl(r[1],r[2]||"",r[3],r[4]||"",r[5]||"/",r[6]||"",r[7]||"")}function parseFileUrl(e){const t=r.exec(e),n=t[2];return makeUrl("file:","",t[1]||"","",isAbsolutePath(n)?n:"/"+n,t[3]||"",t[4]||"")}function makeUrl(e,t,r,n,s,i,o){return{scheme:e,user:t,host:r,port:n,path:s,query:i,hash:o,type:7}}function parseUrl(e){if(isSchemeRelativeUrl(e)){const t=parseAbsoluteUrl("http:"+e);return t.scheme="",t.type=6,t}if(isAbsolutePath(e)){const t=parseAbsoluteUrl("http://foo.com"+e);return t.scheme="",t.host="",t.type=5,t}if(isFileUrl(e))return parseFileUrl(e);if(isAbsoluteUrl(e))return parseAbsoluteUrl(e);const t=parseAbsoluteUrl("http://foo.com/"+e);return t.scheme="",t.host="",t.type=e?e.startsWith("?")?3:e.startsWith("#")?2:4:1,t}function stripPathFilename(e){if(e.endsWith("/.."))return e;const t=e.lastIndexOf("/");return e.slice(0,t+1)}function mergePaths(e,t){normalizePath(t,t.type),"/"===e.path?e.path=t.path:e.path=stripPathFilename(t.path)+e.path}function normalizePath(e,t){const r=t<=4,n=e.path.split("/");let s=1,i=0,o=!1;for(let e=1;en&&(n=s)}normalizePath(r,n);const s=r.query+r.hash;switch(n){case 2:case 3:return s;case 4:{const n=r.path.slice(1);return n?isRelative(t||e)&&!isRelative(n)?"./"+n+s:n+s:s||"."}case 5:return r.path+s;default:return r.scheme+"//"+r.user+r.host+r.port+r.path+s}}return resolve}()},"./node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(e,t,r){var n;!function(e){"use strict";var t=Object.defineProperty,r=Object.getOwnPropertyDescriptor,n=Object.getOwnPropertyNames,s=Object.prototype.hasOwnProperty,__copyProps=(e,i,o,a)=>{if(i&&"object"==typeof i||"function"==typeof i)for(let l of n(i))s.call(e,l)||l===o||t(e,l,{get:()=>i[l],enumerable:!(a=r(i,l))||a.enumerable});return e},__toCommonJS=e=>__copyProps(t({},"__esModule",{value:!0}),e),i={};((e,r)=>{for(var n in r)t(e,n,{get:r[n],enumerable:!0})})(i,{decode:()=>decode,decodeGeneratedRanges:()=>decodeGeneratedRanges,decodeOriginalScopes:()=>decodeOriginalScopes,encode:()=>encode,encodeGeneratedRanges:()=>encodeGeneratedRanges,encodeOriginalScopes:()=>encodeOriginalScopes}),e.exports=__toCommonJS(i);var o=",".charCodeAt(0),a=";".charCodeAt(0),l="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",p=new Uint8Array(64),c=new Uint8Array(128);for(let e=0;e>>=1,i&&(r=-2147483648|-r),t+r}function encodeInteger(e,t,r){let n=t-r;n=n<0?-n<<1|1:n<<1;do{let t=31&n;n>>>=5,n>0&&(t|=32),e.write(p[t])}while(n>0);return t}function hasMoreVlq(e,t){return!(e.pos>=t)&&e.peek()!==o}var u=16384,d="undefined"!=typeof TextDecoder?new TextDecoder:"undefined"!=typeof Buffer?{decode:e=>Buffer.from(e.buffer,e.byteOffset,e.byteLength).toString()}:{decode(e){let t="";for(let r=0;r0?t+d.decode(e.subarray(0,r)):t}},m=class{constructor(e){this.pos=0,this.buffer=e}next(){return this.buffer.charCodeAt(this.pos++)}peek(){return this.buffer.charCodeAt(this.pos)}indexOf(e){const{buffer:t,pos:r}=this,n=t.indexOf(e,r);return-1===n?t.length:n}},f=[];function decodeOriginalScopes(e){const{length:t}=e,r=new m(e),n=[],s=[];let i=0;for(;r.pos0&&r.write(o),n[0]=encodeInteger(r,i,n[0]),encodeInteger(r,a,0),encodeInteger(r,c,0),encodeInteger(r,6===s.length?1:0,0),6===s.length&&encodeInteger(r,s[5],0);for(const e of u)encodeInteger(r,e,0);for(t++;tl||i===l&&o>=p)break;t=_encodeOriginalScopes(e,t,r,n)}return r.write(o),n[0]=encodeInteger(r,l,n[0]),encodeInteger(r,p,0),t}function decodeGeneratedRanges(e){const{length:t}=e,r=new m(e),n=[],s=[];let i=0,o=0,a=0,l=0,p=0,c=0,u=0,d=0;do{const e=r.indexOf(";");let t=0;for(;r.pose;t--){const e=u;u=decodeInteger(r,u),d=decodeInteger(r,u===e?d:0);const t=decodeInteger(r,0);n.push([t,u,d])}}else n=[[e]];x.push(n)}while(hasMoreVlq(r,e))}b.bindings=x,n.push(b),s.push(b)}i++,r.pos=e+1}while(r.pos0&&r.write(o),n[1]=encodeInteger(r,s[1],n[1]),encodeInteger(r,(6===s.length?1:0)|(u?2:0)|(c?4:0),0),6===s.length){const{4:e,5:t}=s;e!==n[2]&&(n[3]=0),n[2]=encodeInteger(r,e,n[2]),n[3]=encodeInteger(r,t,n[3])}if(u){const{0:e,1:t,2:i}=s.callsite;e!==n[4]?(n[5]=0,n[6]=0):t!==n[5]&&(n[6]=0),n[4]=encodeInteger(r,e,n[4]),n[5]=encodeInteger(r,t,n[5]),n[6]=encodeInteger(r,i,n[6])}if(d)for(const e of d){e.length>1&&encodeInteger(r,-e.length,0),encodeInteger(r,e[0][0],0);let t=i,n=a;for(let s=1;sl||i===l&&o>=p)break;t=_encodeGeneratedRanges(e,t,r,n)}return n[0]0&&t.write(a),0===p.length)continue;let c=0;for(let e=0;e0&&t.write(o),c=encodeInteger(t,a[0],c),1!==a.length&&(r=encodeInteger(t,a[1],r),n=encodeInteger(t,a[2],n),s=encodeInteger(t,a[3],s),4!==a.length&&(i=encodeInteger(t,a[4],i)))}}return t.flush()}}(e=r.nmd(e)),e.exports="default"in(n=e).exports?n.exports.default:n.exports},"./node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(e,t,r){var n;!function(e,t,r){"use strict";var n=Object.create,s=Object.defineProperty,i=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,a=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,__commonJS=(e,t)=>function(){return t||(0,e[o(e)[0]])((t={exports:{}}).exports,t),t.exports},__export=(e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})},__copyProps=(e,t,r,n)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let a of o(t))l.call(e,a)||a===r||s(e,a,{get:()=>t[a],enumerable:!(n=i(t,a))||n.enumerable});return e},__toESM=(e,t,r)=>(r=null!=e?n(a(e)):{},__copyProps(!t&&e&&e.__esModule?r:s(r,"default",{value:e,enumerable:!0}),e)),__toCommonJS=e=>__copyProps(s({},"__esModule",{value:!0}),e),p=__commonJS({"umd:@jridgewell/sourcemap-codec"(e,t){t.exports=r}}),c=__commonJS({"umd:@jridgewell/resolve-uri"(e,r){r.exports=t}}),u={};__export(u,{AnyMap:()=>FlattenMap,FlattenMap:()=>FlattenMap,GREATEST_LOWER_BOUND:()=>_,LEAST_UPPER_BOUND:()=>P,TraceMap:()=>A,allGeneratedPositionsFor:()=>allGeneratedPositionsFor,decodedMap:()=>decodedMap,decodedMappings:()=>decodedMappings,eachMapping:()=>eachMapping,encodedMap:()=>encodedMap,encodedMappings:()=>encodedMappings,generatedPositionFor:()=>generatedPositionFor,isIgnored:()=>isIgnored,originalPositionFor:()=>originalPositionFor,presortedDecodedMap:()=>presortedDecodedMap,sourceContentFor:()=>sourceContentFor,traceSegment:()=>traceSegment}),e.exports=__toCommonJS(u);var d=__toESM(p()),h=__toESM(c());function stripFilename(e){if(!e)return"";const t=e.lastIndexOf("/");return e.slice(0,t+1)}function resolver(e,t){const r=stripFilename(e),n=t?t+"/":"";return e=>(0,h.default)(n+(e||""),r)}var m=0,f=1,y=2,b=3,g=4,x=1,v=2;function maybeSort(e,t){const r=nextUnsortedSegmentLine(e,0);if(r===e.length)return e;t||(e=e.slice());for(let n=r;n[]);for(let t=0;t>1),i=e[s][m]-t;if(0===i)return E=!0,s;i<0?r=s+1:n=s-1}return E=!1,r-1}function upperBound(e,t,r){for(let n=r+1;n=0&&e[n][m]===t;r=n--);return r}function memoizedState(){return{lastKey:-1,lastNeedle:-1,lastIndex:-1}}function memoizedBinarySearch(e,t,r,n){const{lastKey:s,lastNeedle:i,lastIndex:o}=r;let a=0,l=e.length-1;if(n===s){if(t===i)return E=-1!==o&&e[o][m]===t,o;t>=i?a=-1===o?0:o:l=o}return r.lastKey=n,r.lastNeedle=t,r.lastIndex=binarySearch(e,t,a,l)}function parse(e){return"string"==typeof e?JSON.parse(e):e}var FlattenMap=function(e,t){const r=parse(e);if(!("sections"in r))return new A(r,t);const n=[],s=[],i=[],o=[],a=[];return recurse(r,t,n,s,i,o,a,0,0,1/0,1/0),presortedDecodedMap({version:3,file:r.file,names:o,sources:s,sourcesContent:i,mappings:n,ignoreList:a})};function recurse(e,t,r,n,s,i,o,a,l,p,c){const{sections:u}=e;for(let e=0;ep)return;const n=getLine(r,t),s=0===e?l:0,i=v[e];for(let e=0;e=c)return;if(1===r.length){n.push([o]);continue}const a=h+r[f],l=r[y],u=r[b];n.push(4===r.length?[o,a,l,u]:[o,a,l,u,x+r[g]])}}}function append(e,t){for(let r=0;r=n.length)return null;const s=n[t],i=traceSegmentInternal(s,cast(e)._decodedMemo,t,r,_);return-1===i?null:s[i]}function originalPositionFor(e,t){let{line:r,column:n,bias:s}=t;if(r--,r<0)throw new Error(T);if(n<0)throw new Error(S);const i=decodedMappings(e);if(r>=i.length)return OMapping(null,null,null,null);const o=i[r],a=traceSegmentInternal(o,cast(e)._decodedMemo,r,n,s||_);if(-1===a)return OMapping(null,null,null,null);const l=o[a];if(1===l.length)return OMapping(null,null,null,null);const{names:p,resolvedSources:c}=e;return OMapping(c[l[f]],l[y]+1,l[b],5===l.length?p[l[g]]:null)}function generatedPositionFor(e,t){const{source:r,line:n,column:s,bias:i}=t;return generatedPosition(e,r,n,s,i||_,!1)}function allGeneratedPositionsFor(e,t){const{source:r,line:n,column:s,bias:i}=t;return generatedPosition(e,r,n,s,i||P,!0)}function eachMapping(e,t){const r=decodedMappings(e),{names:n,resolvedSources:s}=e;for(let e=0;e{"%%"!==e&&(n++,"%c"===e&&(s=n))}),t.splice(s,0,r)},t.save=function(e){try{e?t.storage.setItem("debug",e):t.storage.removeItem("debug")}catch(e){}},t.load=function(){let e;try{e=t.storage.getItem("debug")||t.storage.getItem("DEBUG")}catch(e){}!e&&"undefined"!=typeof process&&"env"in process&&(e=process.env.DEBUG);return e},t.useColors=function(){if("undefined"!=typeof window&&window.process&&("renderer"===window.process.type||window.process.__nwjs))return!0;if("undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))return!1;let e;return"undefined"!=typeof document&&document.documentElement&&document.documentElement.style&&document.documentElement.style.WebkitAppearance||"undefined"!=typeof window&&window.console&&(window.console.firebug||window.console.exception&&window.console.table)||"undefined"!=typeof navigator&&navigator.userAgent&&(e=navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/))&&parseInt(e[1],10)>=31||"undefined"!=typeof navigator&&navigator.userAgent&&navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)},t.storage=function(){try{return localStorage}catch(e){}}(),t.destroy=(()=>{let e=!1;return()=>{e||(e=!0,console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."))}})(),t.colors=["#0000CC","#0000FF","#0033CC","#0033FF","#0066CC","#0066FF","#0099CC","#0099FF","#00CC00","#00CC33","#00CC66","#00CC99","#00CCCC","#00CCFF","#3300CC","#3300FF","#3333CC","#3333FF","#3366CC","#3366FF","#3399CC","#3399FF","#33CC00","#33CC33","#33CC66","#33CC99","#33CCCC","#33CCFF","#6600CC","#6600FF","#6633CC","#6633FF","#66CC00","#66CC33","#9900CC","#9900FF","#9933CC","#9933FF","#99CC00","#99CC33","#CC0000","#CC0033","#CC0066","#CC0099","#CC00CC","#CC00FF","#CC3300","#CC3333","#CC3366","#CC3399","#CC33CC","#CC33FF","#CC6600","#CC6633","#CC9900","#CC9933","#CCCC00","#CCCC33","#FF0000","#FF0033","#FF0066","#FF0099","#FF00CC","#FF00FF","#FF3300","#FF3333","#FF3366","#FF3399","#FF33CC","#FF33FF","#FF6600","#FF6633","#FF9900","#FF9933","#FFCC00","#FFCC33"],t.log=console.debug||console.log||(()=>{}),e.exports=r("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(t);const{formatters:n}=e.exports;n.j=function(e){try{return JSON.stringify(e)}catch(e){return"[UnexpectedJSONParseError]: "+e.message}}},"./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js"(e,t,r){e.exports=function(e){function createDebug(e){let t,r,n,s=null;function debug(...e){if(!debug.enabled)return;const r=debug,n=Number(new Date),s=n-(t||n);r.diff=s,r.prev=t,r.curr=n,t=n,e[0]=createDebug.coerce(e[0]),"string"!=typeof e[0]&&e.unshift("%O");let i=0;e[0]=e[0].replace(/%([a-zA-Z%])/g,(t,n)=>{if("%%"===t)return"%";i++;const s=createDebug.formatters[n];if("function"==typeof s){const n=e[i];t=s.call(r,n),e.splice(i,1),i--}return t}),createDebug.formatArgs.call(r,e);(r.log||createDebug.log).apply(r,e)}return debug.namespace=e,debug.useColors=createDebug.useColors(),debug.color=createDebug.selectColor(e),debug.extend=extend,debug.destroy=createDebug.destroy,Object.defineProperty(debug,"enabled",{enumerable:!0,configurable:!1,get:()=>null!==s?s:(r!==createDebug.namespaces&&(r=createDebug.namespaces,n=createDebug.enabled(e)),n),set:e=>{s=e}}),"function"==typeof createDebug.init&&createDebug.init(debug),debug}function extend(e,t){const r=createDebug(this.namespace+(void 0===t?":":t)+e);return r.log=this.log,r}function matchesTemplate(e,t){let r=0,n=0,s=-1,i=0;for(;r"-"+e)].join(",");return createDebug.enable(""),e},createDebug.enable=function(e){createDebug.save(e),createDebug.namespaces=e,createDebug.names=[],createDebug.skips=[];const t=("string"==typeof e?e:"").trim().replace(/\s+/g,",").split(",").filter(Boolean);for(const e of t)"-"===e[0]?createDebug.skips.push(e.slice(1)):createDebug.names.push(e)},createDebug.enabled=function(e){for(const t of createDebug.skips)if(matchesTemplate(e,t))return!1;for(const t of createDebug.names)if(matchesTemplate(e,t))return!0;return!1},createDebug.humanize=r("./node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"),createDebug.destroy=function(){console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.")},Object.keys(e).forEach(t=>{createDebug[t]=e[t]}),createDebug.names=[],createDebug.skips=[],createDebug.formatters={},createDebug.selectColor=function(e){let t=0;for(let r=0;r{},"Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."),t.colors=[6,2,3,4,5,1];try{const e=r("./node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js");e&&(e.stderr||e).level>=2&&(t.colors=[20,21,26,27,32,33,38,39,40,41,42,43,44,45,56,57,62,63,68,69,74,75,76,77,78,79,80,81,92,93,98,99,112,113,128,129,134,135,148,149,160,161,162,163,164,165,166,167,168,169,170,171,172,173,178,179,184,185,196,197,198,199,200,201,202,203,204,205,206,207,208,209,214,215,220,221])}catch(e){}t.inspectOpts=Object.keys(process.env).filter(e=>/^debug_/i.test(e)).reduce((e,t)=>{const r=t.substring(6).toLowerCase().replace(/_([a-z])/g,(e,t)=>t.toUpperCase());let n=process.env[t];return n=!!/^(yes|on|true|enabled)$/i.test(n)||!/^(no|off|false|disabled)$/i.test(n)&&("null"===n?null:Number(n)),e[r]=n,e},{}),e.exports=r("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(t);const{formatters:i}=e.exports;i.o=function(e){return this.inspectOpts.colors=this.useColors,s.inspect(e,this.inspectOpts).split("\n").map(e=>e.trim()).join(" ")},i.O=function(e){return this.inspectOpts.colors=this.useColors,s.inspect(e,this.inspectOpts)}},"./node_modules/.pnpm/gensync@1.0.0-beta.2/node_modules/gensync/index.js"(e){"use strict";const t=Symbol.for("gensync:v1:start"),r=Symbol.for("gensync:v1:suspend"),n="GENSYNC_OPTIONS_ERROR",s="GENSYNC_RACE_NONEMPTY",i="GENSYNC_ERRBACK_NO_CALLBACK";function assertTypeof(e,t,r,s){if(typeof r===e||s&&void 0===r)return;let i;throw i=s?`Expected opts.${t} to be either a ${e}, or undefined.`:`Expected opts.${t} to be a ${e}.`,makeError(i,n)}function makeError(e,t){return Object.assign(new Error(e),{code:t})}function buildOperation({name:e,arity:n,sync:s,async:i}){return setFunctionMetadata(e,n,function*(...e){const n=yield t;if(!n){return s.call(this,e)}let o;try{i.call(this,e,e=>{o||(o={value:e},n())},e=>{o||(o={err:e},n())})}catch(e){o={err:e},n()}if(yield r,o.hasOwnProperty("err"))throw o.err;return o.value})}function evaluateSync(e){let t;for(;!({value:t}=e.next()).done;)assertStart(t,e);return t}function evaluateAsync(e,t,r){!function step(){try{let r;for(;!({value:r}=e.next()).done;){assertStart(r,e);let t=!0,n=!1;const s=e.next(()=>{t?n=!0:step()});if(t=!1,assertSuspend(s,e),!n)return}return t(r)}catch(e){return r(e)}}()}function assertStart(e,r){e!==t&&throwError(r,makeError(`Got unexpected yielded value in gensync generator: ${JSON.stringify(e)}. Did you perhaps mean to use 'yield*' instead of 'yield'?`,"GENSYNC_EXPECTED_START"))}function assertSuspend({value:e,done:t},n){(t||e!==r)&&throwError(n,makeError(t?"Unexpected generator completion. If you get this, it is probably a gensync bug.":`Expected GENSYNC_SUSPEND, got ${JSON.stringify(e)}. If you get this, it is probably a gensync bug.`,"GENSYNC_EXPECTED_SUSPEND"))}function throwError(e,t){throw e.throw&&e.throw(t),t}function setFunctionMetadata(e,t,r){if("string"==typeof e){const t=Object.getOwnPropertyDescriptor(r,"name");t&&!t.configurable||Object.defineProperty(r,"name",Object.assign(t||{},{configurable:!0,value:e}))}if("number"==typeof t){const e=Object.getOwnPropertyDescriptor(r,"length");e&&!e.configurable||Object.defineProperty(r,"length",Object.assign(e||{},{configurable:!0,value:t}))}return r}e.exports=Object.assign(function(e){let t=e;return t="function"!=typeof e?function({name:e,arity:t,sync:r,async:s,errback:i}){if(assertTypeof("string","name",e,!0),assertTypeof("number","arity",t,!0),assertTypeof("function","sync",r),assertTypeof("function","async",s,!0),assertTypeof("function","errback",i,!0),s&&i)throw makeError("Expected one of either opts.async or opts.errback, but got _both_.",n);if("string"!=typeof e){let t;i&&i.name&&"errback"!==i.name&&(t=i.name),s&&s.name&&"async"!==s.name&&(t=s.name.replace(/Async$/,"")),r&&r.name&&"sync"!==r.name&&(t=r.name.replace(/Sync$/,"")),"string"==typeof t&&(e=t)}"number"!=typeof t&&(t=r.length);return buildOperation({name:e,arity:t,sync:function(e){return r.apply(this,e)},async:function(e,t,n){s?s.apply(this,e).then(t,n):i?i.call(this,...e,(e,r)=>{null==e?t(r):n(e)}):t(r.apply(this,e))}})}(e):function(e){return setFunctionMetadata(e.name,e.length,function(...t){return e.apply(this,t)})}(e),Object.assign(t,function(e){const t={sync:function(...t){return evaluateSync(e.apply(this,t))},async:function(...t){return new Promise((r,n)=>{evaluateAsync(e.apply(this,t),r,n)})},errback:function(...t){const r=t.pop();if("function"!=typeof r)throw makeError("Asynchronous function called without callback",i);let n;try{n=e.apply(this,t)}catch(e){return void r(e)}evaluateAsync(n,e=>r(void 0,e),e=>r(e))}};return t}(t))},{all:buildOperation({name:"all",arity:1,sync:function(e){return Array.from(e[0]).map(e=>evaluateSync(e))},async:function(e,t,r){const n=Array.from(e[0]);if(0===n.length)return void Promise.resolve().then(()=>t([]));let s=0;const i=n.map(()=>{});n.forEach((e,n)=>{evaluateAsync(e,e=>{i[n]=e,s+=1,s===i.length&&t(i)},r)})}}),race:buildOperation({name:"race",arity:1,sync:function(e){const t=Array.from(e[0]);if(0===t.length)throw makeError("Must race at least 1 item",s);return evaluateSync(t[0])},async:function(e,t,r){const n=Array.from(e[0]);if(0===n.length)throw makeError("Must race at least 1 item",s);for(const e of n)evaluateAsync(e,t,r)}})})},"./node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(e){"use strict";e.exports=(e,t=process.argv)=>{const r=e.startsWith("-")?"":1===e.length?"-":"--",n=t.indexOf(r+e),s=t.indexOf("--");return-1!==n&&(-1===s||n{for(const n in e)r.call(e,n)&&t(n,e[n])},fourHexEscape=e=>"\\u"+("0000"+e).slice(-4),hexadecimal=(e,t)=>{let r=e.toString(16);return t?r:r.toUpperCase()},n=t.toString,s=Array.isArray,isBigInt=e=>"bigint"==typeof e,i={"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"},o=/[\\\b\f\n\r\t]/,a=/[0-9]/,l=/[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/,p=/([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^]/g,c=/([\uD800-\uDBFF][\uDC00-\uDFFF])|([\uD800-\uDFFF])|(['"`])|[^ !#-&\(-\[\]-_a-~]/g,jsesc=(e,t)=>{const increaseIndentation=()=>{g=b,++t.indentLevel,b=t.indent.repeat(t.indentLevel)},r={escapeEverything:!1,minimal:!1,isScriptContext:!1,quotes:"single",wrap:!1,es6:!1,json:!1,compact:!0,lowercaseHex:!1,numbers:"decimal",indent:"\t",indentLevel:0,__inline1__:!1,__inline2__:!1},u=t&&t.json;var d,h;u&&(r.quotes="double",r.wrap=!0),d=r,"single"!=(t=(h=t)?(forOwn(h,(e,t)=>{d[e]=t}),d):d).quotes&&"double"!=t.quotes&&"backtick"!=t.quotes&&(t.quotes="single");const m="double"==t.quotes?'"':"backtick"==t.quotes?"`":"'",f=t.compact,y=t.lowercaseHex;let b=t.indent.repeat(t.indentLevel),g="";const x=t.__inline1__,v=t.__inline2__,E=f?"":"\n";let T,S=!0;const P="binary"==t.numbers,_="octal"==t.numbers,A="decimal"==t.numbers,C="hexadecimal"==t.numbers;if(u&&e&&(e=>"function"==typeof e)(e.toJSON)&&(e=e.toJSON()),!(e=>"string"==typeof e||"[object String]"==n.call(e))(e)){if((e=>"[object Map]"==n.call(e))(e))return 0==e.size?"new Map()":(f||(t.__inline1__=!0,t.__inline2__=!1),"new Map("+jsesc(Array.from(e),t)+")");if((e=>"[object Set]"==n.call(e))(e))return 0==e.size?"new Set()":"new Set("+jsesc(Array.from(e),t)+")";if((e=>"function"==typeof Buffer&&Buffer.isBuffer(e))(e))return 0==e.length?"Buffer.from([])":"Buffer.from("+jsesc(Array.from(e),t)+")";if(s(e))return T=[],t.wrap=!0,x&&(t.__inline1__=!1,t.__inline2__=!0),v||increaseIndentation(),((e,t)=>{const r=e.length;let n=-1;for(;++n{S=!1,v&&(t.__inline2__=!1),T.push((f||v?"":b)+jsesc(e,t))}),S?"[]":v?"["+T.join(", ")+"]":"["+E+T.join(","+E)+E+(f?"":g)+"]";if((e=>"number"==typeof e||"[object Number]"==n.call(e))(e)||isBigInt(e)){if(u)return JSON.stringify(Number(e));let t;if(A)t=String(e);else if(C){let r=e.toString(16);y||(r=r.toUpperCase()),t="0x"+r}else P?t="0b"+e.toString(2):_&&(t="0o"+e.toString(8));return isBigInt(e)?t+"n":t}return isBigInt(e)?u?JSON.stringify(Number(e)):e+"n":(e=>"[object Object]"==n.call(e))(e)?(T=[],t.wrap=!0,increaseIndentation(),forOwn(e,(e,r)=>{S=!1,T.push((f?"":b)+jsesc(e,t)+":"+(f?"":" ")+jsesc(r,t))}),S?"{}":"{"+E+T.join(","+E)+E+(f?"":g)+"}"):u?JSON.stringify(e)||"null":String(e)}const w=t.escapeEverything?p:c;return T=e.replace(w,(e,r,n,s,p,c)=>{if(r){if(t.minimal)return r;const e=r.charCodeAt(0),n=r.charCodeAt(1);if(t.es6){return"\\u{"+hexadecimal(1024*(e-55296)+n-56320+65536,y)+"}"}return fourHexEscape(hexadecimal(e,y))+fourHexEscape(hexadecimal(n,y))}if(n)return fourHexEscape(hexadecimal(n.charCodeAt(0),y));if("\0"==e&&!u&&!a.test(c.charAt(p+1)))return"\\0";if(s)return s==m||t.escapeEverything?"\\"+s:s;if(o.test(e))return i[e];if(t.minimal&&!l.test(e))return e;const d=hexadecimal(e.charCodeAt(0),y);return u||d.length>2?fourHexEscape(d):"\\x"+("00"+d).slice(-2)}),"`"==m&&(T=T.replace(/\$\{/g,"\\${")),t.isScriptContext&&(T=T.replace(/<\/(script|style)/gi,"<\\/$1").replace(/
+
+```
+
+#### Modules
+```html
+
+```
+
+## API
+The JSON5 API is compatible with the [JSON API].
+
+[JSON API]:
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON
+
+### JSON5.parse()
+Parses a JSON5 string, constructing the JavaScript value or object described by
+the string. An optional reviver function can be provided to perform a
+transformation on the resulting object before it is returned.
+
+#### Syntax
+ JSON5.parse(text[, reviver])
+
+#### Parameters
+- `text`: The string to parse as JSON5.
+- `reviver`: If a function, this prescribes how the value originally produced by
+ parsing is transformed, before being returned.
+
+#### Return value
+The object corresponding to the given JSON5 text.
+
+### JSON5.stringify()
+Converts a JavaScript value to a JSON5 string, optionally replacing values if a
+replacer function is specified, or optionally including only the specified
+properties if a replacer array is specified.
+
+#### Syntax
+ JSON5.stringify(value[, replacer[, space]])
+ JSON5.stringify(value[, options])
+
+#### Parameters
+- `value`: The value to convert to a JSON5 string.
+- `replacer`: A function that alters the behavior of the stringification
+ process, or an array of String and Number objects that serve as a whitelist
+ for selecting/filtering the properties of the value object to be included in
+ the JSON5 string. If this value is null or not provided, all properties of the
+ object are included in the resulting JSON5 string.
+- `space`: A String or Number object that's used to insert white space into the
+ output JSON5 string for readability purposes. If this is a Number, it
+ indicates the number of space characters to use as white space; this number is
+ capped at 10 (if it is greater, the value is just 10). Values less than 1
+ indicate that no space should be used. If this is a String, the string (or the
+ first 10 characters of the string, if it's longer than that) is used as white
+ space. If this parameter is not provided (or is null), no white space is used.
+ If white space is used, trailing commas will be used in objects and arrays.
+- `options`: An object with the following properties:
+ - `replacer`: Same as the `replacer` parameter.
+ - `space`: Same as the `space` parameter.
+ - `quote`: A String representing the quote character to use when serializing
+ strings.
+
+#### Return value
+A JSON5 string representing the value.
+
+### Node.js `require()` JSON5 files
+When using Node.js, you can `require()` JSON5 files by adding the following
+statement.
+
+```js
+require('json5/lib/register')
+```
+
+Then you can load a JSON5 file with a Node.js `require()` statement. For
+example:
+
+```js
+const config = require('./config.json5')
+```
+
+## CLI
+Since JSON is more widely used than JSON5, this package includes a CLI for
+converting JSON5 to JSON and for validating the syntax of JSON5 documents.
+
+### Installation
+```sh
+npm install --global json5
+```
+
+### Usage
+```sh
+json5 [options]
+```
+
+If `` is not provided, then STDIN is used.
+
+#### Options:
+- `-s`, `--space`: The number of spaces to indent or `t` for tabs
+- `-o`, `--out-file [file]`: Output to the specified file, otherwise STDOUT
+- `-v`, `--validate`: Validate JSON5 but do not output JSON
+- `-V`, `--version`: Output the version number
+- `-h`, `--help`: Output usage information
+
+## Contributing
+### Development
+```sh
+git clone https://github.com/json5/json5
+cd json5
+npm install
+```
+
+When contributing code, please write relevant tests and run `npm test` and `npm
+run lint` before submitting pull requests. Please use an editor that supports
+[EditorConfig](http://editorconfig.org/).
+
+### Issues
+To report bugs or request features regarding the JSON5 **data format**,
+please submit an issue to the official
+**[_specification_ repository](https://github.com/json5/json5-spec)**.
+
+Note that we will never add any features that make JSON5 incompatible with ES5;
+that compatibility is a fundamental premise of JSON5.
+
+To report bugs or request features regarding this **JavaScript implementation**
+of JSON5, please submit an issue to **_this_ repository**.
+
+### Security Vulnerabilities and Disclosures
+To report a security vulnerability, please follow the follow the guidelines
+described in our [security policy](./SECURITY.md).
+
+## License
+MIT. See [LICENSE.md](./LICENSE.md) for details.
+
+## Credits
+[Aseem Kishore](https://github.com/aseemk) founded this project.
+He wrote a [blog post](https://aseemk.substack.com/p/ignore-the-f-ing-haters-json5)
+about the journey and lessons learned 10 years in.
+
+[Michael Bolin](http://bolinfest.com/) independently arrived at and published
+some of these same ideas with awesome explanations and detail. Recommended
+reading: [Suggested Improvements to JSON](http://bolinfest.com/essays/json.html)
+
+[Douglas Crockford](http://www.crockford.com/) of course designed and built
+JSON, but his state machine diagrams on the [JSON website](http://json.org/), as
+cheesy as it may sound, gave us motivation and confidence that building a new
+parser to implement these ideas was within reach! The original
+implementation of JSON5 was also modeled directly off of Doug’s open-source
+[json_parse.js] parser. We’re grateful for that clean and well-documented
+code.
+
+[json_parse.js]:
+https://github.com/douglascrockford/JSON-js/blob/03157639c7a7cddd2e9f032537f346f1a87c0f6d/json_parse.js
+
+[Max Nanasy](https://github.com/MaxNanasy) has been an early and prolific
+supporter, contributing multiple patches and ideas.
+
+[Andrew Eisenberg](https://github.com/aeisenberg) contributed the original
+`stringify` method.
+
+[Jordan Tucker](https://github.com/jordanbtucker) has aligned JSON5 more closely
+with ES5, wrote the official JSON5 specification, completely rewrote the
+codebase from the ground up, and is actively maintaining this project.
diff --git a/tools/ui/node_modules/json5/dist/index.js b/tools/ui/node_modules/json5/dist/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf86533e36ceb54e825468ea611a8c4b5051308e
--- /dev/null
+++ b/tools/ui/node_modules/json5/dist/index.js
@@ -0,0 +1,1737 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global.JSON5 = factory());
+}(this, (function () { 'use strict';
+
+ function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+ }
+
+ var _global = createCommonjsModule(function (module) {
+ // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+ var global = module.exports = typeof window != 'undefined' && window.Math == Math
+ ? window : typeof self != 'undefined' && self.Math == Math ? self
+ // eslint-disable-next-line no-new-func
+ : Function('return this')();
+ if (typeof __g == 'number') { __g = global; } // eslint-disable-line no-undef
+ });
+
+ var _core = createCommonjsModule(function (module) {
+ var core = module.exports = { version: '2.6.5' };
+ if (typeof __e == 'number') { __e = core; } // eslint-disable-line no-undef
+ });
+ var _core_1 = _core.version;
+
+ var _isObject = function (it) {
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+ };
+
+ var _anObject = function (it) {
+ if (!_isObject(it)) { throw TypeError(it + ' is not an object!'); }
+ return it;
+ };
+
+ var _fails = function (exec) {
+ try {
+ return !!exec();
+ } catch (e) {
+ return true;
+ }
+ };
+
+ // Thank's IE8 for his funny defineProperty
+ var _descriptors = !_fails(function () {
+ return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
+ });
+
+ var document = _global.document;
+ // typeof document.createElement is 'object' in old IE
+ var is = _isObject(document) && _isObject(document.createElement);
+ var _domCreate = function (it) {
+ return is ? document.createElement(it) : {};
+ };
+
+ var _ie8DomDefine = !_descriptors && !_fails(function () {
+ return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;
+ });
+
+ // 7.1.1 ToPrimitive(input [, PreferredType])
+
+ // instead of the ES6 spec version, we didn't implement @@toPrimitive case
+ // and the second argument - flag - preferred type is a string
+ var _toPrimitive = function (it, S) {
+ if (!_isObject(it)) { return it; }
+ var fn, val;
+ if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) { return val; }
+ if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) { return val; }
+ if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) { return val; }
+ throw TypeError("Can't convert object to primitive value");
+ };
+
+ var dP = Object.defineProperty;
+
+ var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {
+ _anObject(O);
+ P = _toPrimitive(P, true);
+ _anObject(Attributes);
+ if (_ie8DomDefine) { try {
+ return dP(O, P, Attributes);
+ } catch (e) { /* empty */ } }
+ if ('get' in Attributes || 'set' in Attributes) { throw TypeError('Accessors not supported!'); }
+ if ('value' in Attributes) { O[P] = Attributes.value; }
+ return O;
+ };
+
+ var _objectDp = {
+ f: f
+ };
+
+ var _propertyDesc = function (bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value: value
+ };
+ };
+
+ var _hide = _descriptors ? function (object, key, value) {
+ return _objectDp.f(object, key, _propertyDesc(1, value));
+ } : function (object, key, value) {
+ object[key] = value;
+ return object;
+ };
+
+ var hasOwnProperty = {}.hasOwnProperty;
+ var _has = function (it, key) {
+ return hasOwnProperty.call(it, key);
+ };
+
+ var id = 0;
+ var px = Math.random();
+ var _uid = function (key) {
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+ };
+
+ var _library = false;
+
+ var _shared = createCommonjsModule(function (module) {
+ var SHARED = '__core-js_shared__';
+ var store = _global[SHARED] || (_global[SHARED] = {});
+
+ (module.exports = function (key, value) {
+ return store[key] || (store[key] = value !== undefined ? value : {});
+ })('versions', []).push({
+ version: _core.version,
+ mode: _library ? 'pure' : 'global',
+ copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
+ });
+ });
+
+ var _functionToString = _shared('native-function-to-string', Function.toString);
+
+ var _redefine = createCommonjsModule(function (module) {
+ var SRC = _uid('src');
+
+ var TO_STRING = 'toString';
+ var TPL = ('' + _functionToString).split(TO_STRING);
+
+ _core.inspectSource = function (it) {
+ return _functionToString.call(it);
+ };
+
+ (module.exports = function (O, key, val, safe) {
+ var isFunction = typeof val == 'function';
+ if (isFunction) { _has(val, 'name') || _hide(val, 'name', key); }
+ if (O[key] === val) { return; }
+ if (isFunction) { _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); }
+ if (O === _global) {
+ O[key] = val;
+ } else if (!safe) {
+ delete O[key];
+ _hide(O, key, val);
+ } else if (O[key]) {
+ O[key] = val;
+ } else {
+ _hide(O, key, val);
+ }
+ // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+ })(Function.prototype, TO_STRING, function toString() {
+ return typeof this == 'function' && this[SRC] || _functionToString.call(this);
+ });
+ });
+
+ var _aFunction = function (it) {
+ if (typeof it != 'function') { throw TypeError(it + ' is not a function!'); }
+ return it;
+ };
+
+ // optional / simple context binding
+
+ var _ctx = function (fn, that, length) {
+ _aFunction(fn);
+ if (that === undefined) { return fn; }
+ switch (length) {
+ case 1: return function (a) {
+ return fn.call(that, a);
+ };
+ case 2: return function (a, b) {
+ return fn.call(that, a, b);
+ };
+ case 3: return function (a, b, c) {
+ return fn.call(that, a, b, c);
+ };
+ }
+ return function (/* ...args */) {
+ return fn.apply(that, arguments);
+ };
+ };
+
+ var PROTOTYPE = 'prototype';
+
+ var $export = function (type, name, source) {
+ var IS_FORCED = type & $export.F;
+ var IS_GLOBAL = type & $export.G;
+ var IS_STATIC = type & $export.S;
+ var IS_PROTO = type & $export.P;
+ var IS_BIND = type & $export.B;
+ var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE];
+ var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
+ var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
+ var key, own, out, exp;
+ if (IS_GLOBAL) { source = name; }
+ for (key in source) {
+ // contains in native
+ own = !IS_FORCED && target && target[key] !== undefined;
+ // export native or passed
+ out = (own ? target : source)[key];
+ // bind timers to global for call from export context
+ exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;
+ // extend global
+ if (target) { _redefine(target, key, out, type & $export.U); }
+ // export
+ if (exports[key] != out) { _hide(exports, key, exp); }
+ if (IS_PROTO && expProto[key] != out) { expProto[key] = out; }
+ }
+ };
+ _global.core = _core;
+ // type bitmap
+ $export.F = 1; // forced
+ $export.G = 2; // global
+ $export.S = 4; // static
+ $export.P = 8; // proto
+ $export.B = 16; // bind
+ $export.W = 32; // wrap
+ $export.U = 64; // safe
+ $export.R = 128; // real proto method for `library`
+ var _export = $export;
+
+ // 7.1.4 ToInteger
+ var ceil = Math.ceil;
+ var floor = Math.floor;
+ var _toInteger = function (it) {
+ return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+ };
+
+ // 7.2.1 RequireObjectCoercible(argument)
+ var _defined = function (it) {
+ if (it == undefined) { throw TypeError("Can't call method on " + it); }
+ return it;
+ };
+
+ // true -> String#at
+ // false -> String#codePointAt
+ var _stringAt = function (TO_STRING) {
+ return function (that, pos) {
+ var s = String(_defined(that));
+ var i = _toInteger(pos);
+ var l = s.length;
+ var a, b;
+ if (i < 0 || i >= l) { return TO_STRING ? '' : undefined; }
+ a = s.charCodeAt(i);
+ return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+ ? TO_STRING ? s.charAt(i) : a
+ : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+ };
+ };
+
+ var $at = _stringAt(false);
+ _export(_export.P, 'String', {
+ // 21.1.3.3 String.prototype.codePointAt(pos)
+ codePointAt: function codePointAt(pos) {
+ return $at(this, pos);
+ }
+ });
+
+ var codePointAt = _core.String.codePointAt;
+
+ var max = Math.max;
+ var min = Math.min;
+ var _toAbsoluteIndex = function (index, length) {
+ index = _toInteger(index);
+ return index < 0 ? max(index + length, 0) : min(index, length);
+ };
+
+ var fromCharCode = String.fromCharCode;
+ var $fromCodePoint = String.fromCodePoint;
+
+ // length should be 1, old FF problem
+ _export(_export.S + _export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
+ // 21.1.2.2 String.fromCodePoint(...codePoints)
+ fromCodePoint: function fromCodePoint(x) {
+ var arguments$1 = arguments;
+ // eslint-disable-line no-unused-vars
+ var res = [];
+ var aLen = arguments.length;
+ var i = 0;
+ var code;
+ while (aLen > i) {
+ code = +arguments$1[i++];
+ if (_toAbsoluteIndex(code, 0x10ffff) !== code) { throw RangeError(code + ' is not a valid code point'); }
+ res.push(code < 0x10000
+ ? fromCharCode(code)
+ : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
+ );
+ } return res.join('');
+ }
+ });
+
+ var fromCodePoint = _core.String.fromCodePoint;
+
+ // This is a generated file. Do not edit.
+ var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+ var ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/;
+ var ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/;
+
+ var unicode = {
+ Space_Separator: Space_Separator,
+ ID_Start: ID_Start,
+ ID_Continue: ID_Continue
+ };
+
+ var util = {
+ isSpaceSeparator: function isSpaceSeparator (c) {
+ return typeof c === 'string' && unicode.Space_Separator.test(c)
+ },
+
+ isIdStartChar: function isIdStartChar (c) {
+ return typeof c === 'string' && (
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c === '$') || (c === '_') ||
+ unicode.ID_Start.test(c)
+ )
+ },
+
+ isIdContinueChar: function isIdContinueChar (c) {
+ return typeof c === 'string' && (
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= '0' && c <= '9') ||
+ (c === '$') || (c === '_') ||
+ (c === '\u200C') || (c === '\u200D') ||
+ unicode.ID_Continue.test(c)
+ )
+ },
+
+ isDigit: function isDigit (c) {
+ return typeof c === 'string' && /[0-9]/.test(c)
+ },
+
+ isHexDigit: function isHexDigit (c) {
+ return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
+ },
+ };
+
+ var source;
+ var parseState;
+ var stack;
+ var pos;
+ var line;
+ var column;
+ var token;
+ var key;
+ var root;
+
+ var parse = function parse (text, reviver) {
+ source = String(text);
+ parseState = 'start';
+ stack = [];
+ pos = 0;
+ line = 1;
+ column = 0;
+ token = undefined;
+ key = undefined;
+ root = undefined;
+
+ do {
+ token = lex();
+
+ // This code is unreachable.
+ // if (!parseStates[parseState]) {
+ // throw invalidParseState()
+ // }
+
+ parseStates[parseState]();
+ } while (token.type !== 'eof')
+
+ if (typeof reviver === 'function') {
+ return internalize({'': root}, '', reviver)
+ }
+
+ return root
+ };
+
+ function internalize (holder, name, reviver) {
+ var value = holder[name];
+ if (value != null && typeof value === 'object') {
+ if (Array.isArray(value)) {
+ for (var i = 0; i < value.length; i++) {
+ var key = String(i);
+ var replacement = internalize(value, key, reviver);
+ if (replacement === undefined) {
+ delete value[key];
+ } else {
+ Object.defineProperty(value, key, {
+ value: replacement,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+ } else {
+ for (var key$1 in value) {
+ var replacement$1 = internalize(value, key$1, reviver);
+ if (replacement$1 === undefined) {
+ delete value[key$1];
+ } else {
+ Object.defineProperty(value, key$1, {
+ value: replacement$1,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+ }
+ }
+
+ return reviver.call(holder, name, value)
+ }
+
+ var lexState;
+ var buffer;
+ var doubleQuote;
+ var sign;
+ var c;
+
+ function lex () {
+ lexState = 'default';
+ buffer = '';
+ doubleQuote = false;
+ sign = 1;
+
+ for (;;) {
+ c = peek();
+
+ // This code is unreachable.
+ // if (!lexStates[lexState]) {
+ // throw invalidLexState(lexState)
+ // }
+
+ var token = lexStates[lexState]();
+ if (token) {
+ return token
+ }
+ }
+ }
+
+ function peek () {
+ if (source[pos]) {
+ return String.fromCodePoint(source.codePointAt(pos))
+ }
+ }
+
+ function read () {
+ var c = peek();
+
+ if (c === '\n') {
+ line++;
+ column = 0;
+ } else if (c) {
+ column += c.length;
+ } else {
+ column++;
+ }
+
+ if (c) {
+ pos += c.length;
+ }
+
+ return c
+ }
+
+ var lexStates = {
+ default: function default$1 () {
+ switch (c) {
+ case '\t':
+ case '\v':
+ case '\f':
+ case ' ':
+ case '\u00A0':
+ case '\uFEFF':
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read();
+ return
+
+ case '/':
+ read();
+ lexState = 'comment';
+ return
+
+ case undefined:
+ read();
+ return newToken('eof')
+ }
+
+ if (util.isSpaceSeparator(c)) {
+ read();
+ return
+ }
+
+ // This code is unreachable.
+ // if (!lexStates[parseState]) {
+ // throw invalidLexState(parseState)
+ // }
+
+ return lexStates[parseState]()
+ },
+
+ comment: function comment () {
+ switch (c) {
+ case '*':
+ read();
+ lexState = 'multiLineComment';
+ return
+
+ case '/':
+ read();
+ lexState = 'singleLineComment';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ multiLineComment: function multiLineComment () {
+ switch (c) {
+ case '*':
+ read();
+ lexState = 'multiLineCommentAsterisk';
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read();
+ },
+
+ multiLineCommentAsterisk: function multiLineCommentAsterisk () {
+ switch (c) {
+ case '*':
+ read();
+ return
+
+ case '/':
+ read();
+ lexState = 'default';
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read();
+ lexState = 'multiLineComment';
+ },
+
+ singleLineComment: function singleLineComment () {
+ switch (c) {
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read();
+ lexState = 'default';
+ return
+
+ case undefined:
+ read();
+ return newToken('eof')
+ }
+
+ read();
+ },
+
+ value: function value () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ case 'n':
+ read();
+ literal('ull');
+ return newToken('null', null)
+
+ case 't':
+ read();
+ literal('rue');
+ return newToken('boolean', true)
+
+ case 'f':
+ read();
+ literal('alse');
+ return newToken('boolean', false)
+
+ case '-':
+ case '+':
+ if (read() === '-') {
+ sign = -1;
+ }
+
+ lexState = 'sign';
+ return
+
+ case '.':
+ buffer = read();
+ lexState = 'decimalPointLeading';
+ return
+
+ case '0':
+ buffer = read();
+ lexState = 'zero';
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read();
+ lexState = 'decimalInteger';
+ return
+
+ case 'I':
+ read();
+ literal('nfinity');
+ return newToken('numeric', Infinity)
+
+ case 'N':
+ read();
+ literal('aN');
+ return newToken('numeric', NaN)
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"');
+ buffer = '';
+ lexState = 'string';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ identifierNameStartEscape: function identifierNameStartEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read();
+ var u = unicodeEscape();
+ switch (u) {
+ case '$':
+ case '_':
+ break
+
+ default:
+ if (!util.isIdStartChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u;
+ lexState = 'identifierName';
+ },
+
+ identifierName: function identifierName () {
+ switch (c) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ buffer += read();
+ return
+
+ case '\\':
+ read();
+ lexState = 'identifierNameEscape';
+ return
+ }
+
+ if (util.isIdContinueChar(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('identifier', buffer)
+ },
+
+ identifierNameEscape: function identifierNameEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read();
+ var u = unicodeEscape();
+ switch (u) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ break
+
+ default:
+ if (!util.isIdContinueChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u;
+ lexState = 'identifierName';
+ },
+
+ sign: function sign$1 () {
+ switch (c) {
+ case '.':
+ buffer = read();
+ lexState = 'decimalPointLeading';
+ return
+
+ case '0':
+ buffer = read();
+ lexState = 'zero';
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read();
+ lexState = 'decimalInteger';
+ return
+
+ case 'I':
+ read();
+ literal('nfinity');
+ return newToken('numeric', sign * Infinity)
+
+ case 'N':
+ read();
+ literal('aN');
+ return newToken('numeric', NaN)
+ }
+
+ throw invalidChar(read())
+ },
+
+ zero: function zero () {
+ switch (c) {
+ case '.':
+ buffer += read();
+ lexState = 'decimalPoint';
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+
+ case 'x':
+ case 'X':
+ buffer += read();
+ lexState = 'hexadecimal';
+ return
+ }
+
+ return newToken('numeric', sign * 0)
+ },
+
+ decimalInteger: function decimalInteger () {
+ switch (c) {
+ case '.':
+ buffer += read();
+ lexState = 'decimalPoint';
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalPointLeading: function decimalPointLeading () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalFraction';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalPoint: function decimalPoint () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalFraction';
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalFraction: function decimalFraction () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalExponent: function decimalExponent () {
+ switch (c) {
+ case '+':
+ case '-':
+ buffer += read();
+ lexState = 'decimalExponentSign';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalExponentInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentSign: function decimalExponentSign () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalExponentInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentInteger: function decimalExponentInteger () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ hexadecimal: function hexadecimal () {
+ if (util.isHexDigit(c)) {
+ buffer += read();
+ lexState = 'hexadecimalInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ hexadecimalInteger: function hexadecimalInteger () {
+ if (util.isHexDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ string: function string () {
+ switch (c) {
+ case '\\':
+ read();
+ buffer += escape();
+ return
+
+ case '"':
+ if (doubleQuote) {
+ read();
+ return newToken('string', buffer)
+ }
+
+ buffer += read();
+ return
+
+ case "'":
+ if (!doubleQuote) {
+ read();
+ return newToken('string', buffer)
+ }
+
+ buffer += read();
+ return
+
+ case '\n':
+ case '\r':
+ throw invalidChar(read())
+
+ case '\u2028':
+ case '\u2029':
+ separatorChar(c);
+ break
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+ },
+
+ start: function start () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ // This code is unreachable since the default lexState handles eof.
+ // case undefined:
+ // return newToken('eof')
+ }
+
+ lexState = 'value';
+ },
+
+ beforePropertyName: function beforePropertyName () {
+ switch (c) {
+ case '$':
+ case '_':
+ buffer = read();
+ lexState = 'identifierName';
+ return
+
+ case '\\':
+ read();
+ lexState = 'identifierNameStartEscape';
+ return
+
+ case '}':
+ return newToken('punctuator', read())
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"');
+ lexState = 'string';
+ return
+ }
+
+ if (util.isIdStartChar(c)) {
+ buffer += read();
+ lexState = 'identifierName';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ afterPropertyName: function afterPropertyName () {
+ if (c === ':') {
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforePropertyValue: function beforePropertyValue () {
+ lexState = 'value';
+ },
+
+ afterPropertyValue: function afterPropertyValue () {
+ switch (c) {
+ case ',':
+ case '}':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforeArrayValue: function beforeArrayValue () {
+ if (c === ']') {
+ return newToken('punctuator', read())
+ }
+
+ lexState = 'value';
+ },
+
+ afterArrayValue: function afterArrayValue () {
+ switch (c) {
+ case ',':
+ case ']':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ end: function end () {
+ // This code is unreachable since it's handled by the default lexState.
+ // if (c === undefined) {
+ // read()
+ // return newToken('eof')
+ // }
+
+ throw invalidChar(read())
+ },
+ };
+
+ function newToken (type, value) {
+ return {
+ type: type,
+ value: value,
+ line: line,
+ column: column,
+ }
+ }
+
+ function literal (s) {
+ for (var i = 0, list = s; i < list.length; i += 1) {
+ var c = list[i];
+
+ var p = peek();
+
+ if (p !== c) {
+ throw invalidChar(read())
+ }
+
+ read();
+ }
+ }
+
+ function escape () {
+ var c = peek();
+ switch (c) {
+ case 'b':
+ read();
+ return '\b'
+
+ case 'f':
+ read();
+ return '\f'
+
+ case 'n':
+ read();
+ return '\n'
+
+ case 'r':
+ read();
+ return '\r'
+
+ case 't':
+ read();
+ return '\t'
+
+ case 'v':
+ read();
+ return '\v'
+
+ case '0':
+ read();
+ if (util.isDigit(peek())) {
+ throw invalidChar(read())
+ }
+
+ return '\0'
+
+ case 'x':
+ read();
+ return hexEscape()
+
+ case 'u':
+ read();
+ return unicodeEscape()
+
+ case '\n':
+ case '\u2028':
+ case '\u2029':
+ read();
+ return ''
+
+ case '\r':
+ read();
+ if (peek() === '\n') {
+ read();
+ }
+
+ return ''
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ throw invalidChar(read())
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ return read()
+ }
+
+ function hexEscape () {
+ var buffer = '';
+ var c = peek();
+
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+
+ c = peek();
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+ }
+
+ function unicodeEscape () {
+ var buffer = '';
+ var count = 4;
+
+ while (count-- > 0) {
+ var c = peek();
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+ }
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+ }
+
+ var parseStates = {
+ start: function start () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push();
+ },
+
+ beforePropertyName: function beforePropertyName () {
+ switch (token.type) {
+ case 'identifier':
+ case 'string':
+ key = token.value;
+ parseState = 'afterPropertyName';
+ return
+
+ case 'punctuator':
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.value !== '}') {
+ // throw invalidToken()
+ // }
+
+ pop();
+ return
+
+ case 'eof':
+ throw invalidEOF()
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterPropertyName: function afterPropertyName () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator' || token.value !== ':') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ parseState = 'beforePropertyValue';
+ },
+
+ beforePropertyValue: function beforePropertyValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push();
+ },
+
+ beforeArrayValue: function beforeArrayValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ if (token.type === 'punctuator' && token.value === ']') {
+ pop();
+ return
+ }
+
+ push();
+ },
+
+ afterPropertyValue: function afterPropertyValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforePropertyName';
+ return
+
+ case '}':
+ pop();
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterArrayValue: function afterArrayValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforeArrayValue';
+ return
+
+ case ']':
+ pop();
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ end: function end () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'eof') {
+ // throw invalidToken()
+ // }
+ },
+ };
+
+ function push () {
+ var value;
+
+ switch (token.type) {
+ case 'punctuator':
+ switch (token.value) {
+ case '{':
+ value = {};
+ break
+
+ case '[':
+ value = [];
+ break
+ }
+
+ break
+
+ case 'null':
+ case 'boolean':
+ case 'numeric':
+ case 'string':
+ value = token.value;
+ break
+
+ // This code is unreachable.
+ // default:
+ // throw invalidToken()
+ }
+
+ if (root === undefined) {
+ root = value;
+ } else {
+ var parent = stack[stack.length - 1];
+ if (Array.isArray(parent)) {
+ parent.push(value);
+ } else {
+ Object.defineProperty(parent, key, {
+ value: value,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+
+ if (value !== null && typeof value === 'object') {
+ stack.push(value);
+
+ if (Array.isArray(value)) {
+ parseState = 'beforeArrayValue';
+ } else {
+ parseState = 'beforePropertyName';
+ }
+ } else {
+ var current = stack[stack.length - 1];
+ if (current == null) {
+ parseState = 'end';
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue';
+ } else {
+ parseState = 'afterPropertyValue';
+ }
+ }
+ }
+
+ function pop () {
+ stack.pop();
+
+ var current = stack[stack.length - 1];
+ if (current == null) {
+ parseState = 'end';
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue';
+ } else {
+ parseState = 'afterPropertyValue';
+ }
+ }
+
+ // This code is unreachable.
+ // function invalidParseState () {
+ // return new Error(`JSON5: invalid parse state '${parseState}'`)
+ // }
+
+ // This code is unreachable.
+ // function invalidLexState (state) {
+ // return new Error(`JSON5: invalid lex state '${state}'`)
+ // }
+
+ function invalidChar (c) {
+ if (c === undefined) {
+ return syntaxError(("JSON5: invalid end of input at " + line + ":" + column))
+ }
+
+ return syntaxError(("JSON5: invalid character '" + (formatChar(c)) + "' at " + line + ":" + column))
+ }
+
+ function invalidEOF () {
+ return syntaxError(("JSON5: invalid end of input at " + line + ":" + column))
+ }
+
+ // This code is unreachable.
+ // function invalidToken () {
+ // if (token.type === 'eof') {
+ // return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+ // }
+
+ // const c = String.fromCodePoint(token.value.codePointAt(0))
+ // return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+ // }
+
+ function invalidIdentifier () {
+ column -= 5;
+ return syntaxError(("JSON5: invalid identifier character at " + line + ":" + column))
+ }
+
+ function separatorChar (c) {
+ console.warn(("JSON5: '" + (formatChar(c)) + "' in strings is not valid ECMAScript; consider escaping"));
+ }
+
+ function formatChar (c) {
+ var replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ };
+
+ if (replacements[c]) {
+ return replacements[c]
+ }
+
+ if (c < ' ') {
+ var hexString = c.charCodeAt(0).toString(16);
+ return '\\x' + ('00' + hexString).substring(hexString.length)
+ }
+
+ return c
+ }
+
+ function syntaxError (message) {
+ var err = new SyntaxError(message);
+ err.lineNumber = line;
+ err.columnNumber = column;
+ return err
+ }
+
+ var stringify = function stringify (value, replacer, space) {
+ var stack = [];
+ var indent = '';
+ var propertyList;
+ var replacerFunc;
+ var gap = '';
+ var quote;
+
+ if (
+ replacer != null &&
+ typeof replacer === 'object' &&
+ !Array.isArray(replacer)
+ ) {
+ space = replacer.space;
+ quote = replacer.quote;
+ replacer = replacer.replacer;
+ }
+
+ if (typeof replacer === 'function') {
+ replacerFunc = replacer;
+ } else if (Array.isArray(replacer)) {
+ propertyList = [];
+ for (var i = 0, list = replacer; i < list.length; i += 1) {
+ var v = list[i];
+
+ var item = (void 0);
+
+ if (typeof v === 'string') {
+ item = v;
+ } else if (
+ typeof v === 'number' ||
+ v instanceof String ||
+ v instanceof Number
+ ) {
+ item = String(v);
+ }
+
+ if (item !== undefined && propertyList.indexOf(item) < 0) {
+ propertyList.push(item);
+ }
+ }
+ }
+
+ if (space instanceof Number) {
+ space = Number(space);
+ } else if (space instanceof String) {
+ space = String(space);
+ }
+
+ if (typeof space === 'number') {
+ if (space > 0) {
+ space = Math.min(10, Math.floor(space));
+ gap = ' '.substr(0, space);
+ }
+ } else if (typeof space === 'string') {
+ gap = space.substr(0, 10);
+ }
+
+ return serializeProperty('', {'': value})
+
+ function serializeProperty (key, holder) {
+ var value = holder[key];
+ if (value != null) {
+ if (typeof value.toJSON5 === 'function') {
+ value = value.toJSON5(key);
+ } else if (typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+ }
+
+ if (replacerFunc) {
+ value = replacerFunc.call(holder, key, value);
+ }
+
+ if (value instanceof Number) {
+ value = Number(value);
+ } else if (value instanceof String) {
+ value = String(value);
+ } else if (value instanceof Boolean) {
+ value = value.valueOf();
+ }
+
+ switch (value) {
+ case null: return 'null'
+ case true: return 'true'
+ case false: return 'false'
+ }
+
+ if (typeof value === 'string') {
+ return quoteString(value, false)
+ }
+
+ if (typeof value === 'number') {
+ return String(value)
+ }
+
+ if (typeof value === 'object') {
+ return Array.isArray(value) ? serializeArray(value) : serializeObject(value)
+ }
+
+ return undefined
+ }
+
+ function quoteString (value) {
+ var quotes = {
+ "'": 0.1,
+ '"': 0.2,
+ };
+
+ var replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ };
+
+ var product = '';
+
+ for (var i = 0; i < value.length; i++) {
+ var c = value[i];
+ switch (c) {
+ case "'":
+ case '"':
+ quotes[c]++;
+ product += c;
+ continue
+
+ case '\0':
+ if (util.isDigit(value[i + 1])) {
+ product += '\\x00';
+ continue
+ }
+ }
+
+ if (replacements[c]) {
+ product += replacements[c];
+ continue
+ }
+
+ if (c < ' ') {
+ var hexString = c.charCodeAt(0).toString(16);
+ product += '\\x' + ('00' + hexString).substring(hexString.length);
+ continue
+ }
+
+ product += c;
+ }
+
+ var quoteChar = quote || Object.keys(quotes).reduce(function (a, b) { return (quotes[a] < quotes[b]) ? a : b; });
+
+ product = product.replace(new RegExp(quoteChar, 'g'), replacements[quoteChar]);
+
+ return quoteChar + product + quoteChar
+ }
+
+ function serializeObject (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value);
+
+ var stepback = indent;
+ indent = indent + gap;
+
+ var keys = propertyList || Object.keys(value);
+ var partial = [];
+ for (var i = 0, list = keys; i < list.length; i += 1) {
+ var key = list[i];
+
+ var propertyString = serializeProperty(key, value);
+ if (propertyString !== undefined) {
+ var member = serializeKey(key) + ':';
+ if (gap !== '') {
+ member += ' ';
+ }
+ member += propertyString;
+ partial.push(member);
+ }
+ }
+
+ var final;
+ if (partial.length === 0) {
+ final = '{}';
+ } else {
+ var properties;
+ if (gap === '') {
+ properties = partial.join(',');
+ final = '{' + properties + '}';
+ } else {
+ var separator = ',\n' + indent;
+ properties = partial.join(separator);
+ final = '{\n' + indent + properties + ',\n' + stepback + '}';
+ }
+ }
+
+ stack.pop();
+ indent = stepback;
+ return final
+ }
+
+ function serializeKey (key) {
+ if (key.length === 0) {
+ return quoteString(key, true)
+ }
+
+ var firstChar = String.fromCodePoint(key.codePointAt(0));
+ if (!util.isIdStartChar(firstChar)) {
+ return quoteString(key, true)
+ }
+
+ for (var i = firstChar.length; i < key.length; i++) {
+ if (!util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
+ return quoteString(key, true)
+ }
+ }
+
+ return key
+ }
+
+ function serializeArray (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value);
+
+ var stepback = indent;
+ indent = indent + gap;
+
+ var partial = [];
+ for (var i = 0; i < value.length; i++) {
+ var propertyString = serializeProperty(String(i), value);
+ partial.push((propertyString !== undefined) ? propertyString : 'null');
+ }
+
+ var final;
+ if (partial.length === 0) {
+ final = '[]';
+ } else {
+ if (gap === '') {
+ var properties = partial.join(',');
+ final = '[' + properties + ']';
+ } else {
+ var separator = ',\n' + indent;
+ var properties$1 = partial.join(separator);
+ final = '[\n' + indent + properties$1 + ',\n' + stepback + ']';
+ }
+ }
+
+ stack.pop();
+ indent = stepback;
+ return final
+ }
+ };
+
+ var JSON5 = {
+ parse: parse,
+ stringify: stringify,
+ };
+
+ var lib = JSON5;
+
+ var es5 = lib;
+
+ return es5;
+
+})));
diff --git a/tools/ui/node_modules/json5/dist/index.min.js b/tools/ui/node_modules/json5/dist/index.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..ddce3e2d49c3227cd05a541ed72278d5e8f4f773
--- /dev/null
+++ b/tools/ui/node_modules/json5/dist/index.min.js
@@ -0,0 +1 @@
+!function(u,D){"object"==typeof exports&&"undefined"!=typeof module?module.exports=D():"function"==typeof define&&define.amd?define(D):u.JSON5=D()}(this,function(){"use strict";function u(u,D){return u(D={exports:{}},D.exports),D.exports}var D=u(function(u){var D=u.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=D)}),e=u(function(u){var D=u.exports={version:"2.6.5"};"number"==typeof __e&&(__e=D)}),r=(e.version,function(u){return"object"==typeof u?null!==u:"function"==typeof u}),t=function(u){if(!r(u))throw TypeError(u+" is not an object!");return u},n=function(u){try{return!!u()}catch(u){return!0}},F=!n(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a}),C=D.document,A=r(C)&&r(C.createElement),i=!F&&!n(function(){return 7!=Object.defineProperty((u="div",A?C.createElement(u):{}),"a",{get:function(){return 7}}).a;var u}),E=Object.defineProperty,o={f:F?Object.defineProperty:function(u,D,e){if(t(u),D=function(u,D){if(!r(u))return u;var e,t;if(D&&"function"==typeof(e=u.toString)&&!r(t=e.call(u)))return t;if("function"==typeof(e=u.valueOf)&&!r(t=e.call(u)))return t;if(!D&&"function"==typeof(e=u.toString)&&!r(t=e.call(u)))return t;throw TypeError("Can't convert object to primitive value")}(D,!0),t(e),i)try{return E(u,D,e)}catch(u){}if("get"in e||"set"in e)throw TypeError("Accessors not supported!");return"value"in e&&(u[D]=e.value),u}},a=F?function(u,D,e){return o.f(u,D,function(u,D){return{enumerable:!(1&u),configurable:!(2&u),writable:!(4&u),value:D}}(1,e))}:function(u,D,e){return u[D]=e,u},c={}.hasOwnProperty,B=function(u,D){return c.call(u,D)},s=0,f=Math.random(),l=u(function(u){var r=D["__core-js_shared__"]||(D["__core-js_shared__"]={});(u.exports=function(u,D){return r[u]||(r[u]=void 0!==D?D:{})})("versions",[]).push({version:e.version,mode:"global",copyright:"© 2019 Denis Pushkarev (zloirock.ru)"})})("native-function-to-string",Function.toString),d=u(function(u){var r,t="Symbol(".concat(void 0===(r="src")?"":r,")_",(++s+f).toString(36)),n=(""+l).split("toString");e.inspectSource=function(u){return l.call(u)},(u.exports=function(u,e,r,F){var C="function"==typeof r;C&&(B(r,"name")||a(r,"name",e)),u[e]!==r&&(C&&(B(r,t)||a(r,t,u[e]?""+u[e]:n.join(String(e)))),u===D?u[e]=r:F?u[e]?u[e]=r:a(u,e,r):(delete u[e],a(u,e,r)))})(Function.prototype,"toString",function(){return"function"==typeof this&&this[t]||l.call(this)})}),v=function(u,D,e){if(function(u){if("function"!=typeof u)throw TypeError(u+" is not a function!")}(u),void 0===D)return u;switch(e){case 1:return function(e){return u.call(D,e)};case 2:return function(e,r){return u.call(D,e,r)};case 3:return function(e,r,t){return u.call(D,e,r,t)}}return function(){return u.apply(D,arguments)}},p=function(u,r,t){var n,F,C,A,i=u&p.F,E=u&p.G,o=u&p.S,c=u&p.P,B=u&p.B,s=E?D:o?D[r]||(D[r]={}):(D[r]||{}).prototype,f=E?e:e[r]||(e[r]={}),l=f.prototype||(f.prototype={});for(n in E&&(t=r),t)C=((F=!i&&s&&void 0!==s[n])?s:t)[n],A=B&&F?v(C,D):c&&"function"==typeof C?v(Function.call,C):C,s&&d(s,n,C,u&p.U),f[n]!=C&&a(f,n,A),c&&l[n]!=C&&(l[n]=C)};D.core=e,p.F=1,p.G=2,p.S=4,p.P=8,p.B=16,p.W=32,p.U=64,p.R=128;var h,m=p,g=Math.ceil,y=Math.floor,w=function(u){return isNaN(u=+u)?0:(u>0?y:g)(u)},b=(h=!1,function(u,D){var e,r,t=String(function(u){if(null==u)throw TypeError("Can't call method on "+u);return u}(u)),n=w(D),F=t.length;return n<0||n>=F?h?"":void 0:(e=t.charCodeAt(n))<55296||e>56319||n+1===F||(r=t.charCodeAt(n+1))<56320||r>57343?h?t.charAt(n):e:h?t.slice(n,n+2):r-56320+(e-55296<<10)+65536});m(m.P,"String",{codePointAt:function(u){return b(this,u)}});e.String.codePointAt;var S=Math.max,x=Math.min,N=String.fromCharCode,P=String.fromCodePoint;m(m.S+m.F*(!!P&&1!=P.length),"String",{fromCodePoint:function(u){for(var D,e,r,t=arguments,n=[],F=arguments.length,C=0;F>C;){if(D=+t[C++],r=1114111,((e=w(e=D))<0?S(e+r,0):x(e,r))!==D)throw RangeError(D+" is not a valid code point");n.push(D<65536?N(D):N(55296+((D-=65536)>>10),D%1024+56320))}return n.join("")}});e.String.fromCodePoint;var _,O,j,I,V,J,M,k,L,T,z,H,$,R,G={Space_Separator:/[\u1680\u2000-\u200A\u202F\u205F\u3000]/,ID_Start:/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/,ID_Continue:/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/},U={isSpaceSeparator:function(u){return"string"==typeof u&&G.Space_Separator.test(u)},isIdStartChar:function(u){return"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||"$"===u||"_"===u||G.ID_Start.test(u))},isIdContinueChar:function(u){return"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||u>="0"&&u<="9"||"$"===u||"_"===u||""===u||""===u||G.ID_Continue.test(u))},isDigit:function(u){return"string"==typeof u&&/[0-9]/.test(u)},isHexDigit:function(u){return"string"==typeof u&&/[0-9A-Fa-f]/.test(u)}};function Z(){for(T="default",z="",H=!1,$=1;;){R=q();var u=X[T]();if(u)return u}}function q(){if(_[I])return String.fromCodePoint(_.codePointAt(I))}function W(){var u=q();return"\n"===u?(V++,J=0):u?J+=u.length:J++,u&&(I+=u.length),u}var X={default:function(){switch(R){case"\t":case"\v":case"\f":case" ":case" ":case"\ufeff":case"\n":case"\r":case"\u2028":case"\u2029":return void W();case"/":return W(),void(T="comment");case void 0:return W(),K("eof")}if(!U.isSpaceSeparator(R))return X[O]();W()},comment:function(){switch(R){case"*":return W(),void(T="multiLineComment");case"/":return W(),void(T="singleLineComment")}throw ru(W())},multiLineComment:function(){switch(R){case"*":return W(),void(T="multiLineCommentAsterisk");case void 0:throw ru(W())}W()},multiLineCommentAsterisk:function(){switch(R){case"*":return void W();case"/":return W(),void(T="default");case void 0:throw ru(W())}W(),T="multiLineComment"},singleLineComment:function(){switch(R){case"\n":case"\r":case"\u2028":case"\u2029":return W(),void(T="default");case void 0:return W(),K("eof")}W()},value:function(){switch(R){case"{":case"[":return K("punctuator",W());case"n":return W(),Q("ull"),K("null",null);case"t":return W(),Q("rue"),K("boolean",!0);case"f":return W(),Q("alse"),K("boolean",!1);case"-":case"+":return"-"===W()&&($=-1),void(T="sign");case".":return z=W(),void(T="decimalPointLeading");case"0":return z=W(),void(T="zero");case"1":case"2":case"3":case"4":case"5":case"6":case"7":case"8":case"9":return z=W(),void(T="decimalInteger");case"I":return W(),Q("nfinity"),K("numeric",1/0);case"N":return W(),Q("aN"),K("numeric",NaN);case'"':case"'":return H='"'===W(),z="",void(T="string")}throw ru(W())},identifierNameStartEscape:function(){if("u"!==R)throw ru(W());W();var u=Y();switch(u){case"$":case"_":break;default:if(!U.isIdStartChar(u))throw nu()}z+=u,T="identifierName"},identifierName:function(){switch(R){case"$":case"_":case"":case"":return void(z+=W());case"\\":return W(),void(T="identifierNameEscape")}if(!U.isIdContinueChar(R))return K("identifier",z);z+=W()},identifierNameEscape:function(){if("u"!==R)throw ru(W());W();var u=Y();switch(u){case"$":case"_":case"":case"":break;default:if(!U.isIdContinueChar(u))throw nu()}z+=u,T="identifierName"},sign:function(){switch(R){case".":return z=W(),void(T="decimalPointLeading");case"0":return z=W(),void(T="zero");case"1":case"2":case"3":case"4":case"5":case"6":case"7":case"8":case"9":return z=W(),void(T="decimalInteger");case"I":return W(),Q("nfinity"),K("numeric",$*(1/0));case"N":return W(),Q("aN"),K("numeric",NaN)}throw ru(W())},zero:function(){switch(R){case".":return z+=W(),void(T="decimalPoint");case"e":case"E":return z+=W(),void(T="decimalExponent");case"x":case"X":return z+=W(),void(T="hexadecimal")}return K("numeric",0*$)},decimalInteger:function(){switch(R){case".":return z+=W(),void(T="decimalPoint");case"e":case"E":return z+=W(),void(T="decimalExponent")}if(!U.isDigit(R))return K("numeric",$*Number(z));z+=W()},decimalPointLeading:function(){if(U.isDigit(R))return z+=W(),void(T="decimalFraction");throw ru(W())},decimalPoint:function(){switch(R){case"e":case"E":return z+=W(),void(T="decimalExponent")}return U.isDigit(R)?(z+=W(),void(T="decimalFraction")):K("numeric",$*Number(z))},decimalFraction:function(){switch(R){case"e":case"E":return z+=W(),void(T="decimalExponent")}if(!U.isDigit(R))return K("numeric",$*Number(z));z+=W()},decimalExponent:function(){switch(R){case"+":case"-":return z+=W(),void(T="decimalExponentSign")}if(U.isDigit(R))return z+=W(),void(T="decimalExponentInteger");throw ru(W())},decimalExponentSign:function(){if(U.isDigit(R))return z+=W(),void(T="decimalExponentInteger");throw ru(W())},decimalExponentInteger:function(){if(!U.isDigit(R))return K("numeric",$*Number(z));z+=W()},hexadecimal:function(){if(U.isHexDigit(R))return z+=W(),void(T="hexadecimalInteger");throw ru(W())},hexadecimalInteger:function(){if(!U.isHexDigit(R))return K("numeric",$*Number(z));z+=W()},string:function(){switch(R){case"\\":return W(),void(z+=function(){switch(q()){case"b":return W(),"\b";case"f":return W(),"\f";case"n":return W(),"\n";case"r":return W(),"\r";case"t":return W(),"\t";case"v":return W(),"\v";case"0":if(W(),U.isDigit(q()))throw ru(W());return"\0";case"x":return W(),function(){var u="",D=q();if(!U.isHexDigit(D))throw ru(W());if(u+=W(),D=q(),!U.isHexDigit(D))throw ru(W());return u+=W(),String.fromCodePoint(parseInt(u,16))}();case"u":return W(),Y();case"\n":case"\u2028":case"\u2029":return W(),"";case"\r":return W(),"\n"===q()&&W(),"";case"1":case"2":case"3":case"4":case"5":case"6":case"7":case"8":case"9":case void 0:throw ru(W())}return W()}());case'"':return H?(W(),K("string",z)):void(z+=W());case"'":return H?void(z+=W()):(W(),K("string",z));case"\n":case"\r":throw ru(W());case"\u2028":case"\u2029":!function(u){console.warn("JSON5: '"+Fu(u)+"' in strings is not valid ECMAScript; consider escaping")}(R);break;case void 0:throw ru(W())}z+=W()},start:function(){switch(R){case"{":case"[":return K("punctuator",W())}T="value"},beforePropertyName:function(){switch(R){case"$":case"_":return z=W(),void(T="identifierName");case"\\":return W(),void(T="identifierNameStartEscape");case"}":return K("punctuator",W());case'"':case"'":return H='"'===W(),void(T="string")}if(U.isIdStartChar(R))return z+=W(),void(T="identifierName");throw ru(W())},afterPropertyName:function(){if(":"===R)return K("punctuator",W());throw ru(W())},beforePropertyValue:function(){T="value"},afterPropertyValue:function(){switch(R){case",":case"}":return K("punctuator",W())}throw ru(W())},beforeArrayValue:function(){if("]"===R)return K("punctuator",W());T="value"},afterArrayValue:function(){switch(R){case",":case"]":return K("punctuator",W())}throw ru(W())},end:function(){throw ru(W())}};function K(u,D){return{type:u,value:D,line:V,column:J}}function Q(u){for(var D=0,e=u;D0;){var e=q();if(!U.isHexDigit(e))throw ru(W());u+=W()}return String.fromCodePoint(parseInt(u,16))}var uu={start:function(){if("eof"===M.type)throw tu();Du()},beforePropertyName:function(){switch(M.type){case"identifier":case"string":return k=M.value,void(O="afterPropertyName");case"punctuator":return void eu();case"eof":throw tu()}},afterPropertyName:function(){if("eof"===M.type)throw tu();O="beforePropertyValue"},beforePropertyValue:function(){if("eof"===M.type)throw tu();Du()},beforeArrayValue:function(){if("eof"===M.type)throw tu();"punctuator"!==M.type||"]"!==M.value?Du():eu()},afterPropertyValue:function(){if("eof"===M.type)throw tu();switch(M.value){case",":return void(O="beforePropertyName");case"}":eu()}},afterArrayValue:function(){if("eof"===M.type)throw tu();switch(M.value){case",":return void(O="beforeArrayValue");case"]":eu()}},end:function(){}};function Du(){var u;switch(M.type){case"punctuator":switch(M.value){case"{":u={};break;case"[":u=[]}break;case"null":case"boolean":case"numeric":case"string":u=M.value}if(void 0===L)L=u;else{var D=j[j.length-1];Array.isArray(D)?D.push(u):Object.defineProperty(D,k,{value:u,writable:!0,enumerable:!0,configurable:!0})}if(null!==u&&"object"==typeof u)j.push(u),O=Array.isArray(u)?"beforeArrayValue":"beforePropertyName";else{var e=j[j.length-1];O=null==e?"end":Array.isArray(e)?"afterArrayValue":"afterPropertyValue"}}function eu(){j.pop();var u=j[j.length-1];O=null==u?"end":Array.isArray(u)?"afterArrayValue":"afterPropertyValue"}function ru(u){return Cu(void 0===u?"JSON5: invalid end of input at "+V+":"+J:"JSON5: invalid character '"+Fu(u)+"' at "+V+":"+J)}function tu(){return Cu("JSON5: invalid end of input at "+V+":"+J)}function nu(){return Cu("JSON5: invalid identifier character at "+V+":"+(J-=5))}function Fu(u){var D={"'":"\\'",'"':'\\"',"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\v","\0":"\\0","\u2028":"\\u2028","\u2029":"\\u2029"};if(D[u])return D[u];if(u<" "){var e=u.charCodeAt(0).toString(16);return"\\x"+("00"+e).substring(e.length)}return u}function Cu(u){var D=new SyntaxError(u);return D.lineNumber=V,D.columnNumber=J,D}return{parse:function(u,D){_=String(u),O="start",j=[],I=0,V=1,J=0,M=void 0,k=void 0,L=void 0;do{M=Z(),uu[O]()}while("eof"!==M.type);return"function"==typeof D?function u(D,e,r){var t=D[e];if(null!=t&&"object"==typeof t)if(Array.isArray(t))for(var n=0;n0&&(e=Math.min(10,Math.floor(e)),A=" ".substr(0,e)):"string"==typeof e&&(A=e.substr(0,10)),c("",{"":u});function c(u,D){var e=D[u];switch(null!=e&&("function"==typeof e.toJSON5?e=e.toJSON5(u):"function"==typeof e.toJSON&&(e=e.toJSON(u))),t&&(e=t.call(D,u,e)),e instanceof Number?e=Number(e):e instanceof String?e=String(e):e instanceof Boolean&&(e=e.valueOf()),e){case null:return"null";case!0:return"true";case!1:return"false"}return"string"==typeof e?B(e):"number"==typeof e?String(e):"object"==typeof e?Array.isArray(e)?function(u){if(F.indexOf(u)>=0)throw TypeError("Converting circular structure to JSON5");F.push(u);var D=C;C+=A;for(var e,r=[],t=0;t=0)throw TypeError("Converting circular structure to JSON5");F.push(u);var D=C;C+=A;for(var e,t,n=r||Object.keys(u),i=[],E=0,o=n;E"string"==typeof u&&unicode.Space_Separator.test(u),isIdStartChar:u=>"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||"$"===u||"_"===u||unicode.ID_Start.test(u)),isIdContinueChar:u=>"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||u>="0"&&u<="9"||"$"===u||"_"===u||""===u||""===u||unicode.ID_Continue.test(u)),isDigit:u=>"string"==typeof u&&/[0-9]/.test(u),isHexDigit:u=>"string"==typeof u&&/[0-9A-Fa-f]/.test(u)};let source,parseState,stack,pos,line,column,token,key,root;var parse=function(u,D){source=String(u),parseState="start",stack=[],pos=0,line=1,column=0,token=void 0,key=void 0,root=void 0;do{token=lex(),parseStates[parseState]()}while("eof"!==token.type);return"function"==typeof D?internalize({"":root},"",D):root};function internalize(u,D,e){const r=u[D];if(null!=r&&"object"==typeof r)if(Array.isArray(r))for(let u=0;u0;){const D=peek();if(!util.isHexDigit(D))throw invalidChar(read());u+=read()}return String.fromCodePoint(parseInt(u,16))}const parseStates={start(){if("eof"===token.type)throw invalidEOF();push()},beforePropertyName(){switch(token.type){case"identifier":case"string":return key=token.value,void(parseState="afterPropertyName");case"punctuator":return void pop();case"eof":throw invalidEOF()}},afterPropertyName(){if("eof"===token.type)throw invalidEOF();parseState="beforePropertyValue"},beforePropertyValue(){if("eof"===token.type)throw invalidEOF();push()},beforeArrayValue(){if("eof"===token.type)throw invalidEOF();"punctuator"!==token.type||"]"!==token.value?push():pop()},afterPropertyValue(){if("eof"===token.type)throw invalidEOF();switch(token.value){case",":return void(parseState="beforePropertyName");case"}":pop()}},afterArrayValue(){if("eof"===token.type)throw invalidEOF();switch(token.value){case",":return void(parseState="beforeArrayValue");case"]":pop()}},end(){}};function push(){let u;switch(token.type){case"punctuator":switch(token.value){case"{":u={};break;case"[":u=[]}break;case"null":case"boolean":case"numeric":case"string":u=token.value}if(void 0===root)root=u;else{const D=stack[stack.length-1];Array.isArray(D)?D.push(u):Object.defineProperty(D,key,{value:u,writable:!0,enumerable:!0,configurable:!0})}if(null!==u&&"object"==typeof u)stack.push(u),parseState=Array.isArray(u)?"beforeArrayValue":"beforePropertyName";else{const u=stack[stack.length-1];parseState=null==u?"end":Array.isArray(u)?"afterArrayValue":"afterPropertyValue"}}function pop(){stack.pop();const u=stack[stack.length-1];parseState=null==u?"end":Array.isArray(u)?"afterArrayValue":"afterPropertyValue"}function invalidChar(u){return syntaxError(void 0===u?`JSON5: invalid end of input at ${line}:${column}`:`JSON5: invalid character '${formatChar(u)}' at ${line}:${column}`)}function invalidEOF(){return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)}function invalidIdentifier(){return syntaxError(`JSON5: invalid identifier character at ${line}:${column-=5}`)}function separatorChar(u){console.warn(`JSON5: '${formatChar(u)}' in strings is not valid ECMAScript; consider escaping`)}function formatChar(u){const D={"'":"\\'",'"':'\\"',"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\v","\0":"\\0","\u2028":"\\u2028","\u2029":"\\u2029"};if(D[u])return D[u];if(u<" "){const D=u.charCodeAt(0).toString(16);return"\\x"+("00"+D).substring(D.length)}return u}function syntaxError(u){const D=new SyntaxError(u);return D.lineNumber=line,D.columnNumber=column,D}var stringify=function(u,D,e){const r=[];let t,F,C,a="",A="";if(null==D||"object"!=typeof D||Array.isArray(D)||(e=D.space,C=D.quote,D=D.replacer),"function"==typeof D)F=D;else if(Array.isArray(D)){t=[];for(const u of D){let D;"string"==typeof u?D=u:("number"==typeof u||u instanceof String||u instanceof Number)&&(D=String(u)),void 0!==D&&t.indexOf(D)<0&&t.push(D)}}return e instanceof Number?e=Number(e):e instanceof String&&(e=String(e)),"number"==typeof e?e>0&&(e=Math.min(10,Math.floor(e)),A=" ".substr(0,e)):"string"==typeof e&&(A=e.substr(0,10)),n("",{"":u});function n(u,D){let e=D[u];switch(null!=e&&("function"==typeof e.toJSON5?e=e.toJSON5(u):"function"==typeof e.toJSON&&(e=e.toJSON(u))),F&&(e=F.call(D,u,e)),e instanceof Number?e=Number(e):e instanceof String?e=String(e):e instanceof Boolean&&(e=e.valueOf()),e){case null:return"null";case!0:return"true";case!1:return"false"}return"string"==typeof e?E(e):"number"==typeof e?String(e):"object"==typeof e?Array.isArray(e)?function(u){if(r.indexOf(u)>=0)throw TypeError("Converting circular structure to JSON5");r.push(u);let D=a;a+=A;let e,t=[];for(let D=0;D=0)throw TypeError("Converting circular structure to JSON5");r.push(u);let D=a;a+=A;let e,F=t||Object.keys(u),C=[];for(const D of F){const e=n(D,u);if(void 0!==e){let u=i(D)+":";""!==A&&(u+=" "),u+=e,C.push(u)}}if(0===C.length)e="{}";else{let u;if(""===A)u=C.join(","),e="{"+u+"}";else{let r=",\n"+a;u=C.join(r),e="{\n"+a+u+",\n"+D+"}"}}return r.pop(),a=D,e}(e):void 0}function E(u){const D={"'":.1,'"':.2},e={"'":"\\'",'"':'\\"',"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\v","\0":"\\0","\u2028":"\\u2028","\u2029":"\\u2029"};let r="";for(let t=0;tD[u]= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c === '$') || (c === '_') ||
+ unicode.ID_Start.test(c)
+ )
+ },
+
+ isIdContinueChar (c) {
+ return typeof c === 'string' && (
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= '0' && c <= '9') ||
+ (c === '$') || (c === '_') ||
+ (c === '\u200C') || (c === '\u200D') ||
+ unicode.ID_Continue.test(c)
+ )
+ },
+
+ isDigit (c) {
+ return typeof c === 'string' && /[0-9]/.test(c)
+ },
+
+ isHexDigit (c) {
+ return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
+ },
+};
+
+let source;
+let parseState;
+let stack;
+let pos;
+let line;
+let column;
+let token;
+let key;
+let root;
+
+var parse = function parse (text, reviver) {
+ source = String(text);
+ parseState = 'start';
+ stack = [];
+ pos = 0;
+ line = 1;
+ column = 0;
+ token = undefined;
+ key = undefined;
+ root = undefined;
+
+ do {
+ token = lex();
+
+ // This code is unreachable.
+ // if (!parseStates[parseState]) {
+ // throw invalidParseState()
+ // }
+
+ parseStates[parseState]();
+ } while (token.type !== 'eof')
+
+ if (typeof reviver === 'function') {
+ return internalize({'': root}, '', reviver)
+ }
+
+ return root
+};
+
+function internalize (holder, name, reviver) {
+ const value = holder[name];
+ if (value != null && typeof value === 'object') {
+ if (Array.isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ const key = String(i);
+ const replacement = internalize(value, key, reviver);
+ if (replacement === undefined) {
+ delete value[key];
+ } else {
+ Object.defineProperty(value, key, {
+ value: replacement,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+ } else {
+ for (const key in value) {
+ const replacement = internalize(value, key, reviver);
+ if (replacement === undefined) {
+ delete value[key];
+ } else {
+ Object.defineProperty(value, key, {
+ value: replacement,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+ }
+ }
+
+ return reviver.call(holder, name, value)
+}
+
+let lexState;
+let buffer;
+let doubleQuote;
+let sign;
+let c;
+
+function lex () {
+ lexState = 'default';
+ buffer = '';
+ doubleQuote = false;
+ sign = 1;
+
+ for (;;) {
+ c = peek();
+
+ // This code is unreachable.
+ // if (!lexStates[lexState]) {
+ // throw invalidLexState(lexState)
+ // }
+
+ const token = lexStates[lexState]();
+ if (token) {
+ return token
+ }
+ }
+}
+
+function peek () {
+ if (source[pos]) {
+ return String.fromCodePoint(source.codePointAt(pos))
+ }
+}
+
+function read () {
+ const c = peek();
+
+ if (c === '\n') {
+ line++;
+ column = 0;
+ } else if (c) {
+ column += c.length;
+ } else {
+ column++;
+ }
+
+ if (c) {
+ pos += c.length;
+ }
+
+ return c
+}
+
+const lexStates = {
+ default () {
+ switch (c) {
+ case '\t':
+ case '\v':
+ case '\f':
+ case ' ':
+ case '\u00A0':
+ case '\uFEFF':
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read();
+ return
+
+ case '/':
+ read();
+ lexState = 'comment';
+ return
+
+ case undefined:
+ read();
+ return newToken('eof')
+ }
+
+ if (util.isSpaceSeparator(c)) {
+ read();
+ return
+ }
+
+ // This code is unreachable.
+ // if (!lexStates[parseState]) {
+ // throw invalidLexState(parseState)
+ // }
+
+ return lexStates[parseState]()
+ },
+
+ comment () {
+ switch (c) {
+ case '*':
+ read();
+ lexState = 'multiLineComment';
+ return
+
+ case '/':
+ read();
+ lexState = 'singleLineComment';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ multiLineComment () {
+ switch (c) {
+ case '*':
+ read();
+ lexState = 'multiLineCommentAsterisk';
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read();
+ },
+
+ multiLineCommentAsterisk () {
+ switch (c) {
+ case '*':
+ read();
+ return
+
+ case '/':
+ read();
+ lexState = 'default';
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read();
+ lexState = 'multiLineComment';
+ },
+
+ singleLineComment () {
+ switch (c) {
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read();
+ lexState = 'default';
+ return
+
+ case undefined:
+ read();
+ return newToken('eof')
+ }
+
+ read();
+ },
+
+ value () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ case 'n':
+ read();
+ literal('ull');
+ return newToken('null', null)
+
+ case 't':
+ read();
+ literal('rue');
+ return newToken('boolean', true)
+
+ case 'f':
+ read();
+ literal('alse');
+ return newToken('boolean', false)
+
+ case '-':
+ case '+':
+ if (read() === '-') {
+ sign = -1;
+ }
+
+ lexState = 'sign';
+ return
+
+ case '.':
+ buffer = read();
+ lexState = 'decimalPointLeading';
+ return
+
+ case '0':
+ buffer = read();
+ lexState = 'zero';
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read();
+ lexState = 'decimalInteger';
+ return
+
+ case 'I':
+ read();
+ literal('nfinity');
+ return newToken('numeric', Infinity)
+
+ case 'N':
+ read();
+ literal('aN');
+ return newToken('numeric', NaN)
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"');
+ buffer = '';
+ lexState = 'string';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ identifierNameStartEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read();
+ const u = unicodeEscape();
+ switch (u) {
+ case '$':
+ case '_':
+ break
+
+ default:
+ if (!util.isIdStartChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u;
+ lexState = 'identifierName';
+ },
+
+ identifierName () {
+ switch (c) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ buffer += read();
+ return
+
+ case '\\':
+ read();
+ lexState = 'identifierNameEscape';
+ return
+ }
+
+ if (util.isIdContinueChar(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('identifier', buffer)
+ },
+
+ identifierNameEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read();
+ const u = unicodeEscape();
+ switch (u) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ break
+
+ default:
+ if (!util.isIdContinueChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u;
+ lexState = 'identifierName';
+ },
+
+ sign () {
+ switch (c) {
+ case '.':
+ buffer = read();
+ lexState = 'decimalPointLeading';
+ return
+
+ case '0':
+ buffer = read();
+ lexState = 'zero';
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read();
+ lexState = 'decimalInteger';
+ return
+
+ case 'I':
+ read();
+ literal('nfinity');
+ return newToken('numeric', sign * Infinity)
+
+ case 'N':
+ read();
+ literal('aN');
+ return newToken('numeric', NaN)
+ }
+
+ throw invalidChar(read())
+ },
+
+ zero () {
+ switch (c) {
+ case '.':
+ buffer += read();
+ lexState = 'decimalPoint';
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+
+ case 'x':
+ case 'X':
+ buffer += read();
+ lexState = 'hexadecimal';
+ return
+ }
+
+ return newToken('numeric', sign * 0)
+ },
+
+ decimalInteger () {
+ switch (c) {
+ case '.':
+ buffer += read();
+ lexState = 'decimalPoint';
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalPointLeading () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalFraction';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalPoint () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalFraction';
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalFraction () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read();
+ lexState = 'decimalExponent';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalExponent () {
+ switch (c) {
+ case '+':
+ case '-':
+ buffer += read();
+ lexState = 'decimalExponentSign';
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalExponentInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentSign () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ lexState = 'decimalExponentInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentInteger () {
+ if (util.isDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ hexadecimal () {
+ if (util.isHexDigit(c)) {
+ buffer += read();
+ lexState = 'hexadecimalInteger';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ hexadecimalInteger () {
+ if (util.isHexDigit(c)) {
+ buffer += read();
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ string () {
+ switch (c) {
+ case '\\':
+ read();
+ buffer += escape();
+ return
+
+ case '"':
+ if (doubleQuote) {
+ read();
+ return newToken('string', buffer)
+ }
+
+ buffer += read();
+ return
+
+ case "'":
+ if (!doubleQuote) {
+ read();
+ return newToken('string', buffer)
+ }
+
+ buffer += read();
+ return
+
+ case '\n':
+ case '\r':
+ throw invalidChar(read())
+
+ case '\u2028':
+ case '\u2029':
+ separatorChar(c);
+ break
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+ },
+
+ start () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ // This code is unreachable since the default lexState handles eof.
+ // case undefined:
+ // return newToken('eof')
+ }
+
+ lexState = 'value';
+ },
+
+ beforePropertyName () {
+ switch (c) {
+ case '$':
+ case '_':
+ buffer = read();
+ lexState = 'identifierName';
+ return
+
+ case '\\':
+ read();
+ lexState = 'identifierNameStartEscape';
+ return
+
+ case '}':
+ return newToken('punctuator', read())
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"');
+ lexState = 'string';
+ return
+ }
+
+ if (util.isIdStartChar(c)) {
+ buffer += read();
+ lexState = 'identifierName';
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ afterPropertyName () {
+ if (c === ':') {
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforePropertyValue () {
+ lexState = 'value';
+ },
+
+ afterPropertyValue () {
+ switch (c) {
+ case ',':
+ case '}':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforeArrayValue () {
+ if (c === ']') {
+ return newToken('punctuator', read())
+ }
+
+ lexState = 'value';
+ },
+
+ afterArrayValue () {
+ switch (c) {
+ case ',':
+ case ']':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ end () {
+ // This code is unreachable since it's handled by the default lexState.
+ // if (c === undefined) {
+ // read()
+ // return newToken('eof')
+ // }
+
+ throw invalidChar(read())
+ },
+};
+
+function newToken (type, value) {
+ return {
+ type,
+ value,
+ line,
+ column,
+ }
+}
+
+function literal (s) {
+ for (const c of s) {
+ const p = peek();
+
+ if (p !== c) {
+ throw invalidChar(read())
+ }
+
+ read();
+ }
+}
+
+function escape () {
+ const c = peek();
+ switch (c) {
+ case 'b':
+ read();
+ return '\b'
+
+ case 'f':
+ read();
+ return '\f'
+
+ case 'n':
+ read();
+ return '\n'
+
+ case 'r':
+ read();
+ return '\r'
+
+ case 't':
+ read();
+ return '\t'
+
+ case 'v':
+ read();
+ return '\v'
+
+ case '0':
+ read();
+ if (util.isDigit(peek())) {
+ throw invalidChar(read())
+ }
+
+ return '\0'
+
+ case 'x':
+ read();
+ return hexEscape()
+
+ case 'u':
+ read();
+ return unicodeEscape()
+
+ case '\n':
+ case '\u2028':
+ case '\u2029':
+ read();
+ return ''
+
+ case '\r':
+ read();
+ if (peek() === '\n') {
+ read();
+ }
+
+ return ''
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ throw invalidChar(read())
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ return read()
+}
+
+function hexEscape () {
+ let buffer = '';
+ let c = peek();
+
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+
+ c = peek();
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+}
+
+function unicodeEscape () {
+ let buffer = '';
+ let count = 4;
+
+ while (count-- > 0) {
+ const c = peek();
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read();
+ }
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+}
+
+const parseStates = {
+ start () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push();
+ },
+
+ beforePropertyName () {
+ switch (token.type) {
+ case 'identifier':
+ case 'string':
+ key = token.value;
+ parseState = 'afterPropertyName';
+ return
+
+ case 'punctuator':
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.value !== '}') {
+ // throw invalidToken()
+ // }
+
+ pop();
+ return
+
+ case 'eof':
+ throw invalidEOF()
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterPropertyName () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator' || token.value !== ':') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ parseState = 'beforePropertyValue';
+ },
+
+ beforePropertyValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push();
+ },
+
+ beforeArrayValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ if (token.type === 'punctuator' && token.value === ']') {
+ pop();
+ return
+ }
+
+ push();
+ },
+
+ afterPropertyValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforePropertyName';
+ return
+
+ case '}':
+ pop();
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterArrayValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforeArrayValue';
+ return
+
+ case ']':
+ pop();
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ end () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'eof') {
+ // throw invalidToken()
+ // }
+ },
+};
+
+function push () {
+ let value;
+
+ switch (token.type) {
+ case 'punctuator':
+ switch (token.value) {
+ case '{':
+ value = {};
+ break
+
+ case '[':
+ value = [];
+ break
+ }
+
+ break
+
+ case 'null':
+ case 'boolean':
+ case 'numeric':
+ case 'string':
+ value = token.value;
+ break
+
+ // This code is unreachable.
+ // default:
+ // throw invalidToken()
+ }
+
+ if (root === undefined) {
+ root = value;
+ } else {
+ const parent = stack[stack.length - 1];
+ if (Array.isArray(parent)) {
+ parent.push(value);
+ } else {
+ Object.defineProperty(parent, key, {
+ value,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ });
+ }
+ }
+
+ if (value !== null && typeof value === 'object') {
+ stack.push(value);
+
+ if (Array.isArray(value)) {
+ parseState = 'beforeArrayValue';
+ } else {
+ parseState = 'beforePropertyName';
+ }
+ } else {
+ const current = stack[stack.length - 1];
+ if (current == null) {
+ parseState = 'end';
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue';
+ } else {
+ parseState = 'afterPropertyValue';
+ }
+ }
+}
+
+function pop () {
+ stack.pop();
+
+ const current = stack[stack.length - 1];
+ if (current == null) {
+ parseState = 'end';
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue';
+ } else {
+ parseState = 'afterPropertyValue';
+ }
+}
+
+// This code is unreachable.
+// function invalidParseState () {
+// return new Error(`JSON5: invalid parse state '${parseState}'`)
+// }
+
+// This code is unreachable.
+// function invalidLexState (state) {
+// return new Error(`JSON5: invalid lex state '${state}'`)
+// }
+
+function invalidChar (c) {
+ if (c === undefined) {
+ return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+ }
+
+ return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+}
+
+function invalidEOF () {
+ return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+}
+
+// This code is unreachable.
+// function invalidToken () {
+// if (token.type === 'eof') {
+// return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+// }
+
+// const c = String.fromCodePoint(token.value.codePointAt(0))
+// return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+// }
+
+function invalidIdentifier () {
+ column -= 5;
+ return syntaxError(`JSON5: invalid identifier character at ${line}:${column}`)
+}
+
+function separatorChar (c) {
+ console.warn(`JSON5: '${formatChar(c)}' in strings is not valid ECMAScript; consider escaping`);
+}
+
+function formatChar (c) {
+ const replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ };
+
+ if (replacements[c]) {
+ return replacements[c]
+ }
+
+ if (c < ' ') {
+ const hexString = c.charCodeAt(0).toString(16);
+ return '\\x' + ('00' + hexString).substring(hexString.length)
+ }
+
+ return c
+}
+
+function syntaxError (message) {
+ const err = new SyntaxError(message);
+ err.lineNumber = line;
+ err.columnNumber = column;
+ return err
+}
+
+var stringify = function stringify (value, replacer, space) {
+ const stack = [];
+ let indent = '';
+ let propertyList;
+ let replacerFunc;
+ let gap = '';
+ let quote;
+
+ if (
+ replacer != null &&
+ typeof replacer === 'object' &&
+ !Array.isArray(replacer)
+ ) {
+ space = replacer.space;
+ quote = replacer.quote;
+ replacer = replacer.replacer;
+ }
+
+ if (typeof replacer === 'function') {
+ replacerFunc = replacer;
+ } else if (Array.isArray(replacer)) {
+ propertyList = [];
+ for (const v of replacer) {
+ let item;
+
+ if (typeof v === 'string') {
+ item = v;
+ } else if (
+ typeof v === 'number' ||
+ v instanceof String ||
+ v instanceof Number
+ ) {
+ item = String(v);
+ }
+
+ if (item !== undefined && propertyList.indexOf(item) < 0) {
+ propertyList.push(item);
+ }
+ }
+ }
+
+ if (space instanceof Number) {
+ space = Number(space);
+ } else if (space instanceof String) {
+ space = String(space);
+ }
+
+ if (typeof space === 'number') {
+ if (space > 0) {
+ space = Math.min(10, Math.floor(space));
+ gap = ' '.substr(0, space);
+ }
+ } else if (typeof space === 'string') {
+ gap = space.substr(0, 10);
+ }
+
+ return serializeProperty('', {'': value})
+
+ function serializeProperty (key, holder) {
+ let value = holder[key];
+ if (value != null) {
+ if (typeof value.toJSON5 === 'function') {
+ value = value.toJSON5(key);
+ } else if (typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+ }
+
+ if (replacerFunc) {
+ value = replacerFunc.call(holder, key, value);
+ }
+
+ if (value instanceof Number) {
+ value = Number(value);
+ } else if (value instanceof String) {
+ value = String(value);
+ } else if (value instanceof Boolean) {
+ value = value.valueOf();
+ }
+
+ switch (value) {
+ case null: return 'null'
+ case true: return 'true'
+ case false: return 'false'
+ }
+
+ if (typeof value === 'string') {
+ return quoteString(value, false)
+ }
+
+ if (typeof value === 'number') {
+ return String(value)
+ }
+
+ if (typeof value === 'object') {
+ return Array.isArray(value) ? serializeArray(value) : serializeObject(value)
+ }
+
+ return undefined
+ }
+
+ function quoteString (value) {
+ const quotes = {
+ "'": 0.1,
+ '"': 0.2,
+ };
+
+ const replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ };
+
+ let product = '';
+
+ for (let i = 0; i < value.length; i++) {
+ const c = value[i];
+ switch (c) {
+ case "'":
+ case '"':
+ quotes[c]++;
+ product += c;
+ continue
+
+ case '\0':
+ if (util.isDigit(value[i + 1])) {
+ product += '\\x00';
+ continue
+ }
+ }
+
+ if (replacements[c]) {
+ product += replacements[c];
+ continue
+ }
+
+ if (c < ' ') {
+ let hexString = c.charCodeAt(0).toString(16);
+ product += '\\x' + ('00' + hexString).substring(hexString.length);
+ continue
+ }
+
+ product += c;
+ }
+
+ const quoteChar = quote || Object.keys(quotes).reduce((a, b) => (quotes[a] < quotes[b]) ? a : b);
+
+ product = product.replace(new RegExp(quoteChar, 'g'), replacements[quoteChar]);
+
+ return quoteChar + product + quoteChar
+ }
+
+ function serializeObject (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value);
+
+ let stepback = indent;
+ indent = indent + gap;
+
+ let keys = propertyList || Object.keys(value);
+ let partial = [];
+ for (const key of keys) {
+ const propertyString = serializeProperty(key, value);
+ if (propertyString !== undefined) {
+ let member = serializeKey(key) + ':';
+ if (gap !== '') {
+ member += ' ';
+ }
+ member += propertyString;
+ partial.push(member);
+ }
+ }
+
+ let final;
+ if (partial.length === 0) {
+ final = '{}';
+ } else {
+ let properties;
+ if (gap === '') {
+ properties = partial.join(',');
+ final = '{' + properties + '}';
+ } else {
+ let separator = ',\n' + indent;
+ properties = partial.join(separator);
+ final = '{\n' + indent + properties + ',\n' + stepback + '}';
+ }
+ }
+
+ stack.pop();
+ indent = stepback;
+ return final
+ }
+
+ function serializeKey (key) {
+ if (key.length === 0) {
+ return quoteString(key, true)
+ }
+
+ const firstChar = String.fromCodePoint(key.codePointAt(0));
+ if (!util.isIdStartChar(firstChar)) {
+ return quoteString(key, true)
+ }
+
+ for (let i = firstChar.length; i < key.length; i++) {
+ if (!util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
+ return quoteString(key, true)
+ }
+ }
+
+ return key
+ }
+
+ function serializeArray (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value);
+
+ let stepback = indent;
+ indent = indent + gap;
+
+ let partial = [];
+ for (let i = 0; i < value.length; i++) {
+ const propertyString = serializeProperty(String(i), value);
+ partial.push((propertyString !== undefined) ? propertyString : 'null');
+ }
+
+ let final;
+ if (partial.length === 0) {
+ final = '[]';
+ } else {
+ if (gap === '') {
+ let properties = partial.join(',');
+ final = '[' + properties + ']';
+ } else {
+ let separator = ',\n' + indent;
+ let properties = partial.join(separator);
+ final = '[\n' + indent + properties + ',\n' + stepback + ']';
+ }
+ }
+
+ stack.pop();
+ indent = stepback;
+ return final
+ }
+};
+
+const JSON5 = {
+ parse,
+ stringify,
+};
+
+var lib = JSON5;
+
+export default lib;
diff --git a/tools/ui/node_modules/json5/lib/cli.js b/tools/ui/node_modules/json5/lib/cli.js
new file mode 100644
index 0000000000000000000000000000000000000000..93cb80921e21aed8acfdd81bf5c096138f2e228f
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/cli.js
@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const pkg = require('../package.json')
+const JSON5 = require('./')
+
+const argv = parseArgs()
+
+if (argv.version) {
+ version()
+} else if (argv.help) {
+ usage()
+} else {
+ const inFilename = argv.defaults[0]
+
+ let readStream
+ if (inFilename) {
+ readStream = fs.createReadStream(inFilename)
+ } else {
+ readStream = process.stdin
+ }
+
+ let json5 = ''
+ readStream.on('data', data => {
+ json5 += data
+ })
+
+ readStream.on('end', () => {
+ let space
+ if (argv.space === 't' || argv.space === 'tab') {
+ space = '\t'
+ } else {
+ space = Number(argv.space)
+ }
+
+ let value
+ try {
+ value = JSON5.parse(json5)
+ if (!argv.validate) {
+ const json = JSON.stringify(value, null, space)
+
+ let writeStream
+
+ // --convert is for backward compatibility with v0.5.1. If
+ // specified with and not --out-file, then a file with
+ // the same name but with a .json extension will be written.
+ if (argv.convert && inFilename && !argv.outFile) {
+ const parsedFilename = path.parse(inFilename)
+ const outFilename = path.format(
+ Object.assign(
+ parsedFilename,
+ {base: path.basename(parsedFilename.base, parsedFilename.ext) + '.json'}
+ )
+ )
+
+ writeStream = fs.createWriteStream(outFilename)
+ } else if (argv.outFile) {
+ writeStream = fs.createWriteStream(argv.outFile)
+ } else {
+ writeStream = process.stdout
+ }
+
+ writeStream.write(json)
+ }
+ } catch (err) {
+ console.error(err.message)
+ process.exit(1)
+ }
+ })
+}
+
+function parseArgs () {
+ let convert
+ let space
+ let validate
+ let outFile
+ let version
+ let help
+ const defaults = []
+
+ const args = process.argv.slice(2)
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i]
+ switch (arg) {
+ case '--convert':
+ case '-c':
+ convert = true
+ break
+
+ case '--space':
+ case '-s':
+ space = args[++i]
+ break
+
+ case '--validate':
+ case '-v':
+ validate = true
+ break
+
+ case '--out-file':
+ case '-o':
+ outFile = args[++i]
+ break
+
+ case '--version':
+ case '-V':
+ version = true
+ break
+
+ case '--help':
+ case '-h':
+ help = true
+ break
+
+ default:
+ defaults.push(arg)
+ break
+ }
+ }
+
+ return {
+ convert,
+ space,
+ validate,
+ outFile,
+ version,
+ help,
+ defaults,
+ }
+}
+
+function version () {
+ console.log(pkg.version)
+}
+
+function usage () {
+ console.log(
+ `
+ Usage: json5 [options]
+
+ If is not provided, then STDIN is used.
+
+ Options:
+
+ -s, --space The number of spaces to indent or 't' for tabs
+ -o, --out-file [file] Output to the specified file, otherwise STDOUT
+ -v, --validate Validate JSON5 but do not output JSON
+ -V, --version Output the version number
+ -h, --help Output usage information`
+ )
+}
diff --git a/tools/ui/node_modules/json5/lib/index.d.ts b/tools/ui/node_modules/json5/lib/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c45bca5876aa88b947b4ae32b85f23e64aa1143
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/index.d.ts
@@ -0,0 +1,4 @@
+import parse = require('./parse')
+import stringify = require('./stringify')
+
+export {parse, stringify}
diff --git a/tools/ui/node_modules/json5/lib/index.js b/tools/ui/node_modules/json5/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..36796388892da3dc8cfecd4168d4368aa01edfe1
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/index.js
@@ -0,0 +1,9 @@
+const parse = require('./parse')
+const stringify = require('./stringify')
+
+const JSON5 = {
+ parse,
+ stringify,
+}
+
+module.exports = JSON5
diff --git a/tools/ui/node_modules/json5/lib/parse.d.ts b/tools/ui/node_modules/json5/lib/parse.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8c8d883a27f7b32f48c6c551da323d8885416d24
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/parse.d.ts
@@ -0,0 +1,15 @@
+/**
+ * Parses a JSON5 string, constructing the JavaScript value or object described
+ * by the string.
+ * @template T The type of the return value.
+ * @param text The string to parse as JSON5.
+ * @param reviver A function that prescribes how the value originally produced
+ * by parsing is transformed before being returned.
+ * @returns The JavaScript value converted from the JSON5 string.
+ */
+declare function parse(
+ text: string,
+ reviver?: ((this: any, key: string, value: any) => any) | null,
+): T
+
+export = parse
diff --git a/tools/ui/node_modules/json5/lib/parse.js b/tools/ui/node_modules/json5/lib/parse.js
new file mode 100644
index 0000000000000000000000000000000000000000..da2078a62efd6a47d9ce3e6c70cab55ad262479c
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/parse.js
@@ -0,0 +1,1114 @@
+const util = require('./util')
+
+let source
+let parseState
+let stack
+let pos
+let line
+let column
+let token
+let key
+let root
+
+module.exports = function parse (text, reviver) {
+ source = String(text)
+ parseState = 'start'
+ stack = []
+ pos = 0
+ line = 1
+ column = 0
+ token = undefined
+ key = undefined
+ root = undefined
+
+ do {
+ token = lex()
+
+ // This code is unreachable.
+ // if (!parseStates[parseState]) {
+ // throw invalidParseState()
+ // }
+
+ parseStates[parseState]()
+ } while (token.type !== 'eof')
+
+ if (typeof reviver === 'function') {
+ return internalize({'': root}, '', reviver)
+ }
+
+ return root
+}
+
+function internalize (holder, name, reviver) {
+ const value = holder[name]
+ if (value != null && typeof value === 'object') {
+ if (Array.isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ const key = String(i)
+ const replacement = internalize(value, key, reviver)
+ if (replacement === undefined) {
+ delete value[key]
+ } else {
+ Object.defineProperty(value, key, {
+ value: replacement,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ })
+ }
+ }
+ } else {
+ for (const key in value) {
+ const replacement = internalize(value, key, reviver)
+ if (replacement === undefined) {
+ delete value[key]
+ } else {
+ Object.defineProperty(value, key, {
+ value: replacement,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ })
+ }
+ }
+ }
+ }
+
+ return reviver.call(holder, name, value)
+}
+
+let lexState
+let buffer
+let doubleQuote
+let sign
+let c
+
+function lex () {
+ lexState = 'default'
+ buffer = ''
+ doubleQuote = false
+ sign = 1
+
+ for (;;) {
+ c = peek()
+
+ // This code is unreachable.
+ // if (!lexStates[lexState]) {
+ // throw invalidLexState(lexState)
+ // }
+
+ const token = lexStates[lexState]()
+ if (token) {
+ return token
+ }
+ }
+}
+
+function peek () {
+ if (source[pos]) {
+ return String.fromCodePoint(source.codePointAt(pos))
+ }
+}
+
+function read () {
+ const c = peek()
+
+ if (c === '\n') {
+ line++
+ column = 0
+ } else if (c) {
+ column += c.length
+ } else {
+ column++
+ }
+
+ if (c) {
+ pos += c.length
+ }
+
+ return c
+}
+
+const lexStates = {
+ default () {
+ switch (c) {
+ case '\t':
+ case '\v':
+ case '\f':
+ case ' ':
+ case '\u00A0':
+ case '\uFEFF':
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read()
+ return
+
+ case '/':
+ read()
+ lexState = 'comment'
+ return
+
+ case undefined:
+ read()
+ return newToken('eof')
+ }
+
+ if (util.isSpaceSeparator(c)) {
+ read()
+ return
+ }
+
+ // This code is unreachable.
+ // if (!lexStates[parseState]) {
+ // throw invalidLexState(parseState)
+ // }
+
+ return lexStates[parseState]()
+ },
+
+ comment () {
+ switch (c) {
+ case '*':
+ read()
+ lexState = 'multiLineComment'
+ return
+
+ case '/':
+ read()
+ lexState = 'singleLineComment'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ multiLineComment () {
+ switch (c) {
+ case '*':
+ read()
+ lexState = 'multiLineCommentAsterisk'
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read()
+ },
+
+ multiLineCommentAsterisk () {
+ switch (c) {
+ case '*':
+ read()
+ return
+
+ case '/':
+ read()
+ lexState = 'default'
+ return
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ read()
+ lexState = 'multiLineComment'
+ },
+
+ singleLineComment () {
+ switch (c) {
+ case '\n':
+ case '\r':
+ case '\u2028':
+ case '\u2029':
+ read()
+ lexState = 'default'
+ return
+
+ case undefined:
+ read()
+ return newToken('eof')
+ }
+
+ read()
+ },
+
+ value () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ case 'n':
+ read()
+ literal('ull')
+ return newToken('null', null)
+
+ case 't':
+ read()
+ literal('rue')
+ return newToken('boolean', true)
+
+ case 'f':
+ read()
+ literal('alse')
+ return newToken('boolean', false)
+
+ case '-':
+ case '+':
+ if (read() === '-') {
+ sign = -1
+ }
+
+ lexState = 'sign'
+ return
+
+ case '.':
+ buffer = read()
+ lexState = 'decimalPointLeading'
+ return
+
+ case '0':
+ buffer = read()
+ lexState = 'zero'
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read()
+ lexState = 'decimalInteger'
+ return
+
+ case 'I':
+ read()
+ literal('nfinity')
+ return newToken('numeric', Infinity)
+
+ case 'N':
+ read()
+ literal('aN')
+ return newToken('numeric', NaN)
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"')
+ buffer = ''
+ lexState = 'string'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ identifierNameStartEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read()
+ const u = unicodeEscape()
+ switch (u) {
+ case '$':
+ case '_':
+ break
+
+ default:
+ if (!util.isIdStartChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u
+ lexState = 'identifierName'
+ },
+
+ identifierName () {
+ switch (c) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ buffer += read()
+ return
+
+ case '\\':
+ read()
+ lexState = 'identifierNameEscape'
+ return
+ }
+
+ if (util.isIdContinueChar(c)) {
+ buffer += read()
+ return
+ }
+
+ return newToken('identifier', buffer)
+ },
+
+ identifierNameEscape () {
+ if (c !== 'u') {
+ throw invalidChar(read())
+ }
+
+ read()
+ const u = unicodeEscape()
+ switch (u) {
+ case '$':
+ case '_':
+ case '\u200C':
+ case '\u200D':
+ break
+
+ default:
+ if (!util.isIdContinueChar(u)) {
+ throw invalidIdentifier()
+ }
+
+ break
+ }
+
+ buffer += u
+ lexState = 'identifierName'
+ },
+
+ sign () {
+ switch (c) {
+ case '.':
+ buffer = read()
+ lexState = 'decimalPointLeading'
+ return
+
+ case '0':
+ buffer = read()
+ lexState = 'zero'
+ return
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ buffer = read()
+ lexState = 'decimalInteger'
+ return
+
+ case 'I':
+ read()
+ literal('nfinity')
+ return newToken('numeric', sign * Infinity)
+
+ case 'N':
+ read()
+ literal('aN')
+ return newToken('numeric', NaN)
+ }
+
+ throw invalidChar(read())
+ },
+
+ zero () {
+ switch (c) {
+ case '.':
+ buffer += read()
+ lexState = 'decimalPoint'
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read()
+ lexState = 'decimalExponent'
+ return
+
+ case 'x':
+ case 'X':
+ buffer += read()
+ lexState = 'hexadecimal'
+ return
+ }
+
+ return newToken('numeric', sign * 0)
+ },
+
+ decimalInteger () {
+ switch (c) {
+ case '.':
+ buffer += read()
+ lexState = 'decimalPoint'
+ return
+
+ case 'e':
+ case 'E':
+ buffer += read()
+ lexState = 'decimalExponent'
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read()
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalPointLeading () {
+ if (util.isDigit(c)) {
+ buffer += read()
+ lexState = 'decimalFraction'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalPoint () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read()
+ lexState = 'decimalExponent'
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read()
+ lexState = 'decimalFraction'
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalFraction () {
+ switch (c) {
+ case 'e':
+ case 'E':
+ buffer += read()
+ lexState = 'decimalExponent'
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read()
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ decimalExponent () {
+ switch (c) {
+ case '+':
+ case '-':
+ buffer += read()
+ lexState = 'decimalExponentSign'
+ return
+ }
+
+ if (util.isDigit(c)) {
+ buffer += read()
+ lexState = 'decimalExponentInteger'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentSign () {
+ if (util.isDigit(c)) {
+ buffer += read()
+ lexState = 'decimalExponentInteger'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ decimalExponentInteger () {
+ if (util.isDigit(c)) {
+ buffer += read()
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ hexadecimal () {
+ if (util.isHexDigit(c)) {
+ buffer += read()
+ lexState = 'hexadecimalInteger'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ hexadecimalInteger () {
+ if (util.isHexDigit(c)) {
+ buffer += read()
+ return
+ }
+
+ return newToken('numeric', sign * Number(buffer))
+ },
+
+ string () {
+ switch (c) {
+ case '\\':
+ read()
+ buffer += escape()
+ return
+
+ case '"':
+ if (doubleQuote) {
+ read()
+ return newToken('string', buffer)
+ }
+
+ buffer += read()
+ return
+
+ case "'":
+ if (!doubleQuote) {
+ read()
+ return newToken('string', buffer)
+ }
+
+ buffer += read()
+ return
+
+ case '\n':
+ case '\r':
+ throw invalidChar(read())
+
+ case '\u2028':
+ case '\u2029':
+ separatorChar(c)
+ break
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ buffer += read()
+ },
+
+ start () {
+ switch (c) {
+ case '{':
+ case '[':
+ return newToken('punctuator', read())
+
+ // This code is unreachable since the default lexState handles eof.
+ // case undefined:
+ // return newToken('eof')
+ }
+
+ lexState = 'value'
+ },
+
+ beforePropertyName () {
+ switch (c) {
+ case '$':
+ case '_':
+ buffer = read()
+ lexState = 'identifierName'
+ return
+
+ case '\\':
+ read()
+ lexState = 'identifierNameStartEscape'
+ return
+
+ case '}':
+ return newToken('punctuator', read())
+
+ case '"':
+ case "'":
+ doubleQuote = (read() === '"')
+ lexState = 'string'
+ return
+ }
+
+ if (util.isIdStartChar(c)) {
+ buffer += read()
+ lexState = 'identifierName'
+ return
+ }
+
+ throw invalidChar(read())
+ },
+
+ afterPropertyName () {
+ if (c === ':') {
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforePropertyValue () {
+ lexState = 'value'
+ },
+
+ afterPropertyValue () {
+ switch (c) {
+ case ',':
+ case '}':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ beforeArrayValue () {
+ if (c === ']') {
+ return newToken('punctuator', read())
+ }
+
+ lexState = 'value'
+ },
+
+ afterArrayValue () {
+ switch (c) {
+ case ',':
+ case ']':
+ return newToken('punctuator', read())
+ }
+
+ throw invalidChar(read())
+ },
+
+ end () {
+ // This code is unreachable since it's handled by the default lexState.
+ // if (c === undefined) {
+ // read()
+ // return newToken('eof')
+ // }
+
+ throw invalidChar(read())
+ },
+}
+
+function newToken (type, value) {
+ return {
+ type,
+ value,
+ line,
+ column,
+ }
+}
+
+function literal (s) {
+ for (const c of s) {
+ const p = peek()
+
+ if (p !== c) {
+ throw invalidChar(read())
+ }
+
+ read()
+ }
+}
+
+function escape () {
+ const c = peek()
+ switch (c) {
+ case 'b':
+ read()
+ return '\b'
+
+ case 'f':
+ read()
+ return '\f'
+
+ case 'n':
+ read()
+ return '\n'
+
+ case 'r':
+ read()
+ return '\r'
+
+ case 't':
+ read()
+ return '\t'
+
+ case 'v':
+ read()
+ return '\v'
+
+ case '0':
+ read()
+ if (util.isDigit(peek())) {
+ throw invalidChar(read())
+ }
+
+ return '\0'
+
+ case 'x':
+ read()
+ return hexEscape()
+
+ case 'u':
+ read()
+ return unicodeEscape()
+
+ case '\n':
+ case '\u2028':
+ case '\u2029':
+ read()
+ return ''
+
+ case '\r':
+ read()
+ if (peek() === '\n') {
+ read()
+ }
+
+ return ''
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ throw invalidChar(read())
+
+ case undefined:
+ throw invalidChar(read())
+ }
+
+ return read()
+}
+
+function hexEscape () {
+ let buffer = ''
+ let c = peek()
+
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read()
+
+ c = peek()
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read()
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+}
+
+function unicodeEscape () {
+ let buffer = ''
+ let count = 4
+
+ while (count-- > 0) {
+ const c = peek()
+ if (!util.isHexDigit(c)) {
+ throw invalidChar(read())
+ }
+
+ buffer += read()
+ }
+
+ return String.fromCodePoint(parseInt(buffer, 16))
+}
+
+const parseStates = {
+ start () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push()
+ },
+
+ beforePropertyName () {
+ switch (token.type) {
+ case 'identifier':
+ case 'string':
+ key = token.value
+ parseState = 'afterPropertyName'
+ return
+
+ case 'punctuator':
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.value !== '}') {
+ // throw invalidToken()
+ // }
+
+ pop()
+ return
+
+ case 'eof':
+ throw invalidEOF()
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterPropertyName () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator' || token.value !== ':') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ parseState = 'beforePropertyValue'
+ },
+
+ beforePropertyValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ push()
+ },
+
+ beforeArrayValue () {
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ if (token.type === 'punctuator' && token.value === ']') {
+ pop()
+ return
+ }
+
+ push()
+ },
+
+ afterPropertyValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforePropertyName'
+ return
+
+ case '}':
+ pop()
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ afterArrayValue () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'punctuator') {
+ // throw invalidToken()
+ // }
+
+ if (token.type === 'eof') {
+ throw invalidEOF()
+ }
+
+ switch (token.value) {
+ case ',':
+ parseState = 'beforeArrayValue'
+ return
+
+ case ']':
+ pop()
+ }
+
+ // This code is unreachable since it's handled by the lexState.
+ // throw invalidToken()
+ },
+
+ end () {
+ // This code is unreachable since it's handled by the lexState.
+ // if (token.type !== 'eof') {
+ // throw invalidToken()
+ // }
+ },
+}
+
+function push () {
+ let value
+
+ switch (token.type) {
+ case 'punctuator':
+ switch (token.value) {
+ case '{':
+ value = {}
+ break
+
+ case '[':
+ value = []
+ break
+ }
+
+ break
+
+ case 'null':
+ case 'boolean':
+ case 'numeric':
+ case 'string':
+ value = token.value
+ break
+
+ // This code is unreachable.
+ // default:
+ // throw invalidToken()
+ }
+
+ if (root === undefined) {
+ root = value
+ } else {
+ const parent = stack[stack.length - 1]
+ if (Array.isArray(parent)) {
+ parent.push(value)
+ } else {
+ Object.defineProperty(parent, key, {
+ value,
+ writable: true,
+ enumerable: true,
+ configurable: true,
+ })
+ }
+ }
+
+ if (value !== null && typeof value === 'object') {
+ stack.push(value)
+
+ if (Array.isArray(value)) {
+ parseState = 'beforeArrayValue'
+ } else {
+ parseState = 'beforePropertyName'
+ }
+ } else {
+ const current = stack[stack.length - 1]
+ if (current == null) {
+ parseState = 'end'
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue'
+ } else {
+ parseState = 'afterPropertyValue'
+ }
+ }
+}
+
+function pop () {
+ stack.pop()
+
+ const current = stack[stack.length - 1]
+ if (current == null) {
+ parseState = 'end'
+ } else if (Array.isArray(current)) {
+ parseState = 'afterArrayValue'
+ } else {
+ parseState = 'afterPropertyValue'
+ }
+}
+
+// This code is unreachable.
+// function invalidParseState () {
+// return new Error(`JSON5: invalid parse state '${parseState}'`)
+// }
+
+// This code is unreachable.
+// function invalidLexState (state) {
+// return new Error(`JSON5: invalid lex state '${state}'`)
+// }
+
+function invalidChar (c) {
+ if (c === undefined) {
+ return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+ }
+
+ return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+}
+
+function invalidEOF () {
+ return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+}
+
+// This code is unreachable.
+// function invalidToken () {
+// if (token.type === 'eof') {
+// return syntaxError(`JSON5: invalid end of input at ${line}:${column}`)
+// }
+
+// const c = String.fromCodePoint(token.value.codePointAt(0))
+// return syntaxError(`JSON5: invalid character '${formatChar(c)}' at ${line}:${column}`)
+// }
+
+function invalidIdentifier () {
+ column -= 5
+ return syntaxError(`JSON5: invalid identifier character at ${line}:${column}`)
+}
+
+function separatorChar (c) {
+ console.warn(`JSON5: '${formatChar(c)}' in strings is not valid ECMAScript; consider escaping`)
+}
+
+function formatChar (c) {
+ const replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ }
+
+ if (replacements[c]) {
+ return replacements[c]
+ }
+
+ if (c < ' ') {
+ const hexString = c.charCodeAt(0).toString(16)
+ return '\\x' + ('00' + hexString).substring(hexString.length)
+ }
+
+ return c
+}
+
+function syntaxError (message) {
+ const err = new SyntaxError(message)
+ err.lineNumber = line
+ err.columnNumber = column
+ return err
+}
diff --git a/tools/ui/node_modules/json5/lib/register.js b/tools/ui/node_modules/json5/lib/register.js
new file mode 100644
index 0000000000000000000000000000000000000000..935cdbafb323ac615fc22c86cfbaf3f2359771b8
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/register.js
@@ -0,0 +1,13 @@
+const fs = require('fs')
+const JSON5 = require('./')
+
+// eslint-disable-next-line node/no-deprecated-api
+require.extensions['.json5'] = function (module, filename) {
+ const content = fs.readFileSync(filename, 'utf8')
+ try {
+ module.exports = JSON5.parse(content)
+ } catch (err) {
+ err.message = filename + ': ' + err.message
+ throw err
+ }
+}
diff --git a/tools/ui/node_modules/json5/lib/require.js b/tools/ui/node_modules/json5/lib/require.js
new file mode 100644
index 0000000000000000000000000000000000000000..3aa29bee0344ef9a7c800ccc7a1fd71c55ade4a0
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/require.js
@@ -0,0 +1,4 @@
+// This file is for backward compatibility with v0.5.1.
+require('./register')
+
+console.warn("'json5/require' is deprecated. Please use 'json5/register' instead.")
diff --git a/tools/ui/node_modules/json5/lib/stringify.d.ts b/tools/ui/node_modules/json5/lib/stringify.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c348389eaf56c9c743ad7755bb115a87c19ba68
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/stringify.d.ts
@@ -0,0 +1,89 @@
+declare type StringifyOptions = {
+ /**
+ * A function that alters the behavior of the stringification process, or an
+ * array of String and Number objects that serve as a allowlist for
+ * selecting/filtering the properties of the value object to be included in
+ * the JSON5 string. If this value is null or not provided, all properties
+ * of the object are included in the resulting JSON5 string.
+ */
+ replacer?:
+ | ((this: any, key: string, value: any) => any)
+ | (string | number)[]
+ | null
+
+ /**
+ * A String or Number object that's used to insert white space into the
+ * output JSON5 string for readability purposes. If this is a Number, it
+ * indicates the number of space characters to use as white space; this
+ * number is capped at 10 (if it is greater, the value is just 10). Values
+ * less than 1 indicate that no space should be used. If this is a String,
+ * the string (or the first 10 characters of the string, if it's longer than
+ * that) is used as white space. If this parameter is not provided (or is
+ * null), no white space is used. If white space is used, trailing commas
+ * will be used in objects and arrays.
+ */
+ space?: string | number | null
+
+ /**
+ * A String representing the quote character to use when serializing
+ * strings.
+ */
+ quote?: string | null
+}
+
+/**
+ * Converts a JavaScript value to a JSON5 string.
+ * @param value The value to convert to a JSON5 string.
+ * @param replacer A function that alters the behavior of the stringification
+ * process. If this value is null or not provided, all properties of the object
+ * are included in the resulting JSON5 string.
+ * @param space A String or Number object that's used to insert white space into
+ * the output JSON5 string for readability purposes. If this is a Number, it
+ * indicates the number of space characters to use as white space; this number
+ * is capped at 10 (if it is greater, the value is just 10). Values less than 1
+ * indicate that no space should be used. If this is a String, the string (or
+ * the first 10 characters of the string, if it's longer than that) is used as
+ * white space. If this parameter is not provided (or is null), no white space
+ * is used. If white space is used, trailing commas will be used in objects and
+ * arrays.
+ * @returns The JSON5 string converted from the JavaScript value.
+ */
+declare function stringify(
+ value: any,
+ replacer?: ((this: any, key: string, value: any) => any) | null,
+ space?: string | number | null,
+): string
+
+/**
+ * Converts a JavaScript value to a JSON5 string.
+ * @param value The value to convert to a JSON5 string.
+ * @param replacer An array of String and Number objects that serve as a
+ * allowlist for selecting/filtering the properties of the value object to be
+ * included in the JSON5 string. If this value is null or not provided, all
+ * properties of the object are included in the resulting JSON5 string.
+ * @param space A String or Number object that's used to insert white space into
+ * the output JSON5 string for readability purposes. If this is a Number, it
+ * indicates the number of space characters to use as white space; this number
+ * is capped at 10 (if it is greater, the value is just 10). Values less than 1
+ * indicate that no space should be used. If this is a String, the string (or
+ * the first 10 characters of the string, if it's longer than that) is used as
+ * white space. If this parameter is not provided (or is null), no white space
+ * is used. If white space is used, trailing commas will be used in objects and
+ * arrays.
+ * @returns The JSON5 string converted from the JavaScript value.
+ */
+declare function stringify(
+ value: any,
+ replacer: (string | number)[],
+ space?: string | number | null,
+): string
+
+/**
+ * Converts a JavaScript value to a JSON5 string.
+ * @param value The value to convert to a JSON5 string.
+ * @param options An object specifying options.
+ * @returns The JSON5 string converted from the JavaScript value.
+ */
+declare function stringify(value: any, options: StringifyOptions): string
+
+export = stringify
diff --git a/tools/ui/node_modules/json5/lib/stringify.js b/tools/ui/node_modules/json5/lib/stringify.js
new file mode 100644
index 0000000000000000000000000000000000000000..7cb3b0e101840b22bf620e4b15f46c733054e8e2
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/stringify.js
@@ -0,0 +1,261 @@
+const util = require('./util')
+
+module.exports = function stringify (value, replacer, space) {
+ const stack = []
+ let indent = ''
+ let propertyList
+ let replacerFunc
+ let gap = ''
+ let quote
+
+ if (
+ replacer != null &&
+ typeof replacer === 'object' &&
+ !Array.isArray(replacer)
+ ) {
+ space = replacer.space
+ quote = replacer.quote
+ replacer = replacer.replacer
+ }
+
+ if (typeof replacer === 'function') {
+ replacerFunc = replacer
+ } else if (Array.isArray(replacer)) {
+ propertyList = []
+ for (const v of replacer) {
+ let item
+
+ if (typeof v === 'string') {
+ item = v
+ } else if (
+ typeof v === 'number' ||
+ v instanceof String ||
+ v instanceof Number
+ ) {
+ item = String(v)
+ }
+
+ if (item !== undefined && propertyList.indexOf(item) < 0) {
+ propertyList.push(item)
+ }
+ }
+ }
+
+ if (space instanceof Number) {
+ space = Number(space)
+ } else if (space instanceof String) {
+ space = String(space)
+ }
+
+ if (typeof space === 'number') {
+ if (space > 0) {
+ space = Math.min(10, Math.floor(space))
+ gap = ' '.substr(0, space)
+ }
+ } else if (typeof space === 'string') {
+ gap = space.substr(0, 10)
+ }
+
+ return serializeProperty('', {'': value})
+
+ function serializeProperty (key, holder) {
+ let value = holder[key]
+ if (value != null) {
+ if (typeof value.toJSON5 === 'function') {
+ value = value.toJSON5(key)
+ } else if (typeof value.toJSON === 'function') {
+ value = value.toJSON(key)
+ }
+ }
+
+ if (replacerFunc) {
+ value = replacerFunc.call(holder, key, value)
+ }
+
+ if (value instanceof Number) {
+ value = Number(value)
+ } else if (value instanceof String) {
+ value = String(value)
+ } else if (value instanceof Boolean) {
+ value = value.valueOf()
+ }
+
+ switch (value) {
+ case null: return 'null'
+ case true: return 'true'
+ case false: return 'false'
+ }
+
+ if (typeof value === 'string') {
+ return quoteString(value, false)
+ }
+
+ if (typeof value === 'number') {
+ return String(value)
+ }
+
+ if (typeof value === 'object') {
+ return Array.isArray(value) ? serializeArray(value) : serializeObject(value)
+ }
+
+ return undefined
+ }
+
+ function quoteString (value) {
+ const quotes = {
+ "'": 0.1,
+ '"': 0.2,
+ }
+
+ const replacements = {
+ "'": "\\'",
+ '"': '\\"',
+ '\\': '\\\\',
+ '\b': '\\b',
+ '\f': '\\f',
+ '\n': '\\n',
+ '\r': '\\r',
+ '\t': '\\t',
+ '\v': '\\v',
+ '\0': '\\0',
+ '\u2028': '\\u2028',
+ '\u2029': '\\u2029',
+ }
+
+ let product = ''
+
+ for (let i = 0; i < value.length; i++) {
+ const c = value[i]
+ switch (c) {
+ case "'":
+ case '"':
+ quotes[c]++
+ product += c
+ continue
+
+ case '\0':
+ if (util.isDigit(value[i + 1])) {
+ product += '\\x00'
+ continue
+ }
+ }
+
+ if (replacements[c]) {
+ product += replacements[c]
+ continue
+ }
+
+ if (c < ' ') {
+ let hexString = c.charCodeAt(0).toString(16)
+ product += '\\x' + ('00' + hexString).substring(hexString.length)
+ continue
+ }
+
+ product += c
+ }
+
+ const quoteChar = quote || Object.keys(quotes).reduce((a, b) => (quotes[a] < quotes[b]) ? a : b)
+
+ product = product.replace(new RegExp(quoteChar, 'g'), replacements[quoteChar])
+
+ return quoteChar + product + quoteChar
+ }
+
+ function serializeObject (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value)
+
+ let stepback = indent
+ indent = indent + gap
+
+ let keys = propertyList || Object.keys(value)
+ let partial = []
+ for (const key of keys) {
+ const propertyString = serializeProperty(key, value)
+ if (propertyString !== undefined) {
+ let member = serializeKey(key) + ':'
+ if (gap !== '') {
+ member += ' '
+ }
+ member += propertyString
+ partial.push(member)
+ }
+ }
+
+ let final
+ if (partial.length === 0) {
+ final = '{}'
+ } else {
+ let properties
+ if (gap === '') {
+ properties = partial.join(',')
+ final = '{' + properties + '}'
+ } else {
+ let separator = ',\n' + indent
+ properties = partial.join(separator)
+ final = '{\n' + indent + properties + ',\n' + stepback + '}'
+ }
+ }
+
+ stack.pop()
+ indent = stepback
+ return final
+ }
+
+ function serializeKey (key) {
+ if (key.length === 0) {
+ return quoteString(key, true)
+ }
+
+ const firstChar = String.fromCodePoint(key.codePointAt(0))
+ if (!util.isIdStartChar(firstChar)) {
+ return quoteString(key, true)
+ }
+
+ for (let i = firstChar.length; i < key.length; i++) {
+ if (!util.isIdContinueChar(String.fromCodePoint(key.codePointAt(i)))) {
+ return quoteString(key, true)
+ }
+ }
+
+ return key
+ }
+
+ function serializeArray (value) {
+ if (stack.indexOf(value) >= 0) {
+ throw TypeError('Converting circular structure to JSON5')
+ }
+
+ stack.push(value)
+
+ let stepback = indent
+ indent = indent + gap
+
+ let partial = []
+ for (let i = 0; i < value.length; i++) {
+ const propertyString = serializeProperty(String(i), value)
+ partial.push((propertyString !== undefined) ? propertyString : 'null')
+ }
+
+ let final
+ if (partial.length === 0) {
+ final = '[]'
+ } else {
+ if (gap === '') {
+ let properties = partial.join(',')
+ final = '[' + properties + ']'
+ } else {
+ let separator = ',\n' + indent
+ let properties = partial.join(separator)
+ final = '[\n' + indent + properties + ',\n' + stepback + ']'
+ }
+ }
+
+ stack.pop()
+ indent = stepback
+ return final
+ }
+}
diff --git a/tools/ui/node_modules/json5/lib/unicode.d.ts b/tools/ui/node_modules/json5/lib/unicode.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..610f8057af421224d81b03adc2de89c9d295850e
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/unicode.d.ts
@@ -0,0 +1,3 @@
+export declare const Space_Separator: RegExp
+export declare const ID_Start: RegExp
+export declare const ID_Continue: RegExp
diff --git a/tools/ui/node_modules/json5/lib/unicode.js b/tools/ui/node_modules/json5/lib/unicode.js
new file mode 100644
index 0000000000000000000000000000000000000000..215ccd843abc25c3805ed9307f813f046dcb1459
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/unicode.js
@@ -0,0 +1,4 @@
+// This is a generated file. Do not edit.
+module.exports.Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/
+module.exports.ID_Start = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/
+module.exports.ID_Continue = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/
diff --git a/tools/ui/node_modules/json5/lib/util.d.ts b/tools/ui/node_modules/json5/lib/util.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a940ceadbb079bf7c80360c35b25bbbb9d5aa699
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/util.d.ts
@@ -0,0 +1,5 @@
+export declare function isSpaceSeparator(c?: string): boolean
+export declare function isIdStartChar(c?: string): boolean
+export declare function isIdContinueChar(c?: string): boolean
+export declare function isDigit(c?: string): boolean
+export declare function isHexDigit(c?: string): boolean
diff --git a/tools/ui/node_modules/json5/lib/util.js b/tools/ui/node_modules/json5/lib/util.js
new file mode 100644
index 0000000000000000000000000000000000000000..40bfe2fa6a67b2cc686467eb131fcdf8a0b07cf8
--- /dev/null
+++ b/tools/ui/node_modules/json5/lib/util.js
@@ -0,0 +1,35 @@
+const unicode = require('../lib/unicode')
+
+module.exports = {
+ isSpaceSeparator (c) {
+ return typeof c === 'string' && unicode.Space_Separator.test(c)
+ },
+
+ isIdStartChar (c) {
+ return typeof c === 'string' && (
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c === '$') || (c === '_') ||
+ unicode.ID_Start.test(c)
+ )
+ },
+
+ isIdContinueChar (c) {
+ return typeof c === 'string' && (
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= '0' && c <= '9') ||
+ (c === '$') || (c === '_') ||
+ (c === '\u200C') || (c === '\u200D') ||
+ unicode.ID_Continue.test(c)
+ )
+ },
+
+ isDigit (c) {
+ return typeof c === 'string' && /[0-9]/.test(c)
+ },
+
+ isHexDigit (c) {
+ return typeof c === 'string' && /[0-9A-Fa-f]/.test(c)
+ },
+}
diff --git a/tools/ui/node_modules/json5/package.json b/tools/ui/node_modules/json5/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..60c51d93c0c81bc8c82d13d377c0e1b4fe58c471
--- /dev/null
+++ b/tools/ui/node_modules/json5/package.json
@@ -0,0 +1,72 @@
+{
+ "name": "json5",
+ "version": "2.2.3",
+ "description": "JSON for Humans",
+ "main": "lib/index.js",
+ "module": "dist/index.mjs",
+ "bin": "lib/cli.js",
+ "browser": "dist/index.js",
+ "types": "lib/index.d.ts",
+ "files": [
+ "lib/",
+ "dist/"
+ ],
+ "engines": {
+ "node": ">=6"
+ },
+ "scripts": {
+ "build": "rollup -c",
+ "build-package": "node build/package.js",
+ "build-unicode": "node build/unicode.js",
+ "coverage": "tap --coverage-report html test",
+ "lint": "eslint --fix .",
+ "lint-report": "eslint .",
+ "prepublishOnly": "npm run production",
+ "preversion": "npm run production",
+ "production": "run-s test build",
+ "tap": "tap -Rspec --100 test",
+ "test": "run-s lint-report tap",
+ "version": "npm run build-package && git add package.json5"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/json5/json5.git"
+ },
+ "keywords": [
+ "json",
+ "json5",
+ "es5",
+ "es2015",
+ "ecmascript"
+ ],
+ "author": "Aseem Kishore ",
+ "contributors": [
+ "Max Nanasy ",
+ "Andrew Eisenberg ",
+ "Jordan Tucker "
+ ],
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/json5/json5/issues"
+ },
+ "homepage": "http://json5.org/",
+ "devDependencies": {
+ "core-js": "^2.6.5",
+ "eslint": "^5.15.3",
+ "eslint-config-standard": "^12.0.0",
+ "eslint-plugin-import": "^2.16.0",
+ "eslint-plugin-node": "^8.0.1",
+ "eslint-plugin-promise": "^4.0.1",
+ "eslint-plugin-standard": "^4.0.0",
+ "npm-run-all": "^4.1.5",
+ "regenerate": "^1.4.0",
+ "rollup": "^0.64.1",
+ "rollup-plugin-buble": "^0.19.6",
+ "rollup-plugin-commonjs": "^9.2.1",
+ "rollup-plugin-node-resolve": "^3.4.0",
+ "rollup-plugin-terser": "^1.0.1",
+ "sinon": "^6.3.5",
+ "tap": "^12.6.0",
+ "unicode-10.0.0": "^0.7.5"
+ }
+}
diff --git a/tools/ui/node_modules/jsonc-parser/CHANGELOG.md b/tools/ui/node_modules/jsonc-parser/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..3414a3f1ff933fb9eeb5f36bc8404b448fb73ff7
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/CHANGELOG.md
@@ -0,0 +1,76 @@
+3.3.0 2022-06-24
+=================
+- `JSONVisitor.onObjectBegin` and `JSONVisitor.onArrayBegin` can now return `false` to instruct the visitor that no children should be visited.
+
+
+3.2.0 2022-08-30
+=================
+- update the version of the bundled Javascript files to `es2020`.
+- include all `const enum` values in the bundled JavaScript files (`ScanError`, `SyntaxKind`, `ParseErrorCode`).
+
+3.1.0 2022-07-07
+==================
+ * added new API `FormattingOptions.keepLines` : It leaves the initial line positions in the formatting.
+
+3.0.0 2020-11-13
+==================
+ * fixed API spec for `parseTree`. Can return `undefine` for empty input.
+ * added new API `FormattingOptions.insertFinalNewline`.
+
+
+2.3.0 2020-07-03
+==================
+ * new API `ModificationOptions.isArrayInsertion`: If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then `modify` will insert a new item at that location instead of overwriting its contents.
+ * `ModificationOptions.formattingOptions` is now optional. If not set, newly inserted content will not be formatted.
+
+
+2.2.0 2019-10-25
+==================
+ * added `ParseOptions.allowEmptyContent`. Default is `false`.
+ * new API `getNodeType`: Returns the type of a value returned by parse.
+ * `parse`: Fix issue with empty property name
+
+2.1.0 2019-03-29
+==================
+ * `JSONScanner` and `JSONVisitor` return lineNumber / character.
+
+2.0.0 2018-04-12
+==================
+ * renamed `Node.columnOffset` to `Node.colonOffset`
+ * new API `getNodePath`: Gets the JSON path of the given JSON DOM node
+ * new API `findNodeAtOffset`: Finds the most inner node at the given offset. If `includeRightBound` is set, also finds nodes that end at the given offset.
+
+1.0.3 2018-03-07
+==================
+ * provide ems modules
+
+1.0.2 2018-03-05
+==================
+ * added the `visit.onComment` API, reported when comments are allowed.
+ * added the `ParseErrorCode.InvalidCommentToken` enum value, reported when comments are disallowed.
+
+1.0.1
+==================
+ * added the `format` API: computes edits to format a JSON document.
+ * added the `modify` API: computes edits to insert, remove or replace a property or value in a JSON document.
+ * added the `allyEdits` API: applies edits to a document
+
+1.0.0
+==================
+ * remove nls dependency (remove `getParseErrorMessage`)
+
+0.4.2 / 2017-05-05
+==================
+ * added `ParseError.offset` & `ParseError.length`
+
+0.4.1 / 2017-04-02
+==================
+ * added `ParseOptions.allowTrailingComma`
+
+0.4.0 / 2017-02-23
+==================
+ * fix for `getLocation`. Now `getLocation` inside an object will always return a property from inside that property. Can be empty string if the object has no properties or if the offset is before a actual property `{ "a": { | }} will return location ['a', ' ']`
+
+0.3.0 / 2017-01-17
+==================
+ * Updating to typescript 2.0
\ No newline at end of file
diff --git a/tools/ui/node_modules/jsonc-parser/LICENSE.md b/tools/ui/node_modules/jsonc-parser/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c65de1db32e326f2bd84b036db911248779eaa7
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tools/ui/node_modules/jsonc-parser/README.md b/tools/ui/node_modules/jsonc-parser/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d569b7064f7086e6acc2d75567b45319e579993d
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/README.md
@@ -0,0 +1,364 @@
+# jsonc-parser
+Scanner and parser for JSON with comments.
+
+[](https://www.npmjs.org/package/jsonc-parser)
+[](https://npmjs.org/package/jsonc-parser)
+[](https://github.com/microsoft/node-jsonc-parser/workflows/Tests)
+[](https://opensource.org/licenses/MIT)
+
+Why?
+----
+JSONC is JSON with JavaScript style comments. This node module provides a scanner and fault tolerant parser that can process JSONC but is also useful for standard JSON.
+ - the *scanner* tokenizes the input string into tokens and token offsets
+ - the *visit* function implements a 'SAX' style parser with callbacks for the encountered properties and values.
+ - the *parseTree* function computes a hierarchical DOM with offsets representing the encountered properties and values.
+ - the *parse* function evaluates the JavaScript object represented by JSON string in a fault tolerant fashion.
+ - the *getLocation* API returns a location object that describes the property or value located at a given offset in a JSON document.
+ - the *findNodeAtLocation* API finds the node at a given location path in a JSON DOM.
+ - the *format* API computes edits to format a JSON document.
+ - the *modify* API computes edits to insert, remove or replace a property or value in a JSON document.
+ - the *applyEdits* API applies edits to a document.
+
+Installation
+------------
+
+```
+npm install --save jsonc-parser
+```
+
+API
+---
+
+### Scanner:
+```typescript
+
+/**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+export function createScanner(text: string, ignoreTrivia: boolean = false): JSONScanner;
+
+/**
+ * The scanner object, representing a JSON scanner at a position in the input string.
+ */
+export interface JSONScanner {
+ /**
+ * Sets the scan position to a new offset. A call to 'scan' is needed to get the first token.
+ */
+ setPosition(pos: number): any;
+ /**
+ * Read the next token. Returns the token code.
+ */
+ scan(): SyntaxKind;
+ /**
+ * Returns the zero-based current scan position, which is after the last read token.
+ */
+ getPosition(): number;
+ /**
+ * Returns the last read token.
+ */
+ getToken(): SyntaxKind;
+ /**
+ * Returns the last read token value. The value for strings is the decoded string content. For numbers it's of type number, for boolean it's true or false.
+ */
+ getTokenValue(): string;
+ /**
+ * The zero-based start offset of the last read token.
+ */
+ getTokenOffset(): number;
+ /**
+ * The length of the last read token.
+ */
+ getTokenLength(): number;
+ /**
+ * The zero-based start line number of the last read token.
+ */
+ getTokenStartLine(): number;
+ /**
+ * The zero-based start character (column) of the last read token.
+ */
+ getTokenStartCharacter(): number;
+ /**
+ * An error code of the last scan.
+ */
+ getTokenError(): ScanError;
+}
+```
+
+### Parser:
+```typescript
+
+export interface ParseOptions {
+ disallowComments?: boolean;
+ allowTrailingComma?: boolean;
+ allowEmptyContent?: boolean;
+}
+/**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore always check the errors list to find out if the input was valid.
+ */
+export declare function parse(text: string, errors?: {error: ParseErrorCode;}[], options?: ParseOptions): any;
+
+/**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+export declare function visit(text: string, visitor: JSONVisitor, options?: ParseOptions): any;
+
+/**
+ * Visitor called by {@linkcode visit} when parsing JSON.
+ *
+ * The visitor functions have the following common parameters:
+ * - `offset`: Global offset within the JSON document, starting at 0
+ * - `startLine`: Line number, starting at 0
+ * - `startCharacter`: Start character (column) within the current line, starting at 0
+ *
+ * Additionally some functions have a `pathSupplier` parameter which can be used to obtain the
+ * current `JSONPath` within the document.
+ */
+export interface JSONVisitor {
+ /**
+ * Invoked when an open brace is encountered and an object is started. The offset and length represent the location of the open brace.
+ * When `false` is returned, the array items will not be visited.
+ */
+ onObjectBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void | boolean;
+
+ /**
+ * Invoked when a property is encountered. The offset and length represent the location of the property name.
+ * The `JSONPath` created by the `pathSupplier` refers to the enclosing JSON object, it does not include the
+ * property name yet.
+ */
+ onObjectProperty?: (property: string, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a closing brace is encountered and an object is completed. The offset and length represent the location of the closing brace.
+ */
+ onObjectEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when an open bracket is encountered. The offset and length represent the location of the open bracket.
+ * When `false` is returned, the array items will not be visited.*
+ */
+ onArrayBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void | boolean;
+ /**
+ * Invoked when a closing bracket is encountered. The offset and length represent the location of the closing bracket.
+ */
+ onArrayEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when a literal value is encountered. The offset and length represent the location of the literal value.
+ */
+ onLiteralValue?: (value: any, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a comma or colon separator is encountered. The offset and length represent the location of the separator.
+ */
+ onSeparator?: (character: string, offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * When comments are allowed, invoked when a line or block comment is encountered. The offset and length represent the location of the comment.
+ */
+ onComment?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked on an error.
+ */
+ onError?: (error: ParseErrorCode, offset: number, length: number, startLine: number, startCharacter: number) => void;
+}
+
+/**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+export declare function parseTree(text: string, errors?: ParseError[], options?: ParseOptions): Node | undefined;
+
+export declare type NodeType = "object" | "array" | "property" | "string" | "number" | "boolean" | "null";
+export interface Node {
+ type: NodeType;
+ value?: any;
+ offset: number;
+ length: number;
+ colonOffset?: number;
+ parent?: Node;
+ children?: Node[];
+}
+
+```
+
+### Utilities:
+```typescript
+/**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+export declare function stripComments(text: string, replaceCh?: string): string;
+
+/**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+export declare function getLocation(text: string, position: number): Location;
+
+/**
+ * A {@linkcode JSONPath} segment. Either a string representing an object property name
+ * or a number (starting at 0) for array indices.
+ */
+export declare type Segment = string | number;
+export declare type JSONPath = Segment[];
+export interface Location {
+ /**
+ * The previous property key or literal value (string, number, boolean or null) or undefined.
+ */
+ previousNode?: Node;
+ /**
+ * The path describing the location in the JSON document. The path consists of a sequence strings
+ * representing an object property or numbers for array indices.
+ */
+ path: JSONPath;
+ /**
+ * Matches the locations path against a pattern consisting of strings (for properties) and numbers (for array indices).
+ * '*' will match a single segment, of any property name or index.
+ * '**' will match a sequence of segments or no segment, of any property name or index.
+ */
+ matches: (patterns: JSONPath) => boolean;
+ /**
+ * If set, the location's offset is at a property key.
+ */
+ isAtPropertyKey: boolean;
+}
+
+/**
+ * Finds the node at the given path in a JSON DOM.
+ */
+export function findNodeAtLocation(root: Node, path: JSONPath): Node | undefined;
+
+/**
+ * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+export function findNodeAtOffset(root: Node, offset: number, includeRightBound?: boolean) : Node | undefined;
+
+/**
+ * Gets the JSON path of the given JSON DOM node
+ */
+export function getNodePath(node: Node): JSONPath;
+
+/**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+export function getNodeValue(node: Node): any;
+
+/**
+ * Computes the edit operations needed to format a JSON document.
+ *
+ * @param documentText The input text
+ * @param range The range to format or `undefined` to format the full content
+ * @param options The formatting options
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export function format(documentText: string, range: Range, options: FormattingOptions): EditResult;
+
+/**
+ * Computes the edit operations needed to modify a value in the JSON document.
+ *
+ * @param documentText The input text
+ * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+ * If the path points to an non-existing property or item, it will be created.
+ * @param value The new value for the specified property or item. If the value is undefined,
+ * the property or item will be removed.
+ * @param options Options
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export function modify(text: string, path: JSONPath, value: any, options: ModificationOptions): EditResult;
+
+/**
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+ */
+export function applyEdits(text: string, edits: EditResult): string;
+
+/**
+ * An edit result describes a textual edit operation. It is the result of a {@linkcode format} and {@linkcode modify} operation.
+ * It consist of one or more edits describing insertions, replacements or removals of text segments.
+ * * The offsets of the edits refer to the original state of the document.
+ * * No two edits change or remove the same range of text in the original document.
+ * * Multiple edits can have the same offset if they are multiple inserts, or an insert followed by a remove or replace.
+ * * The order in the array defines which edit is applied first.
+ * To apply an edit result use {@linkcode applyEdits}.
+ * In general multiple EditResults must not be concatenated because they might impact each other, producing incorrect or malformed JSON data.
+ */
+export type EditResult = Edit[];
+
+/**
+ * Represents a text modification
+ */
+export interface Edit {
+ /**
+ * The start offset of the modification.
+ */
+ offset: number;
+ /**
+ * The length of the modification. Must not be negative. Empty length represents an *insert*.
+ */
+ length: number;
+ /**
+ * The new content. Empty content represents a *remove*.
+ */
+ content: string;
+}
+
+/**
+ * A text range in the document
+*/
+export interface Range {
+ /**
+ * The start offset of the range.
+ */
+ offset: number;
+ /**
+ * The length of the range. Must not be negative.
+ */
+ length: number;
+}
+
+/**
+ * Options used by {@linkcode format} when computing the formatting edit operations
+ */
+export interface FormattingOptions {
+ /**
+ * If indentation is based on spaces (`insertSpaces` = true), then what is the number of spaces that make an indent?
+ */
+ tabSize: number;
+ /**
+ * Is indentation based on spaces?
+ */
+ insertSpaces: boolean;
+ /**
+ * The default 'end of line' character
+ */
+ eol: string;
+}
+
+/**
+ * Options used by {@linkcode modify} when computing the modification edit operations
+ */
+export interface ModificationOptions {
+ /**
+ * Formatting options. If undefined, the newly inserted code will be inserted unformatted.
+ */
+ formattingOptions?: FormattingOptions;
+ /**
+ * Default false. If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then
+ * {@linkcode modify} will insert a new item at that location instead of overwriting its contents.
+ */
+ isArrayInsertion?: boolean;
+ /**
+ * Optional function to define the insertion index given an existing list of properties.
+ */
+ getInsertionIndex?: (properties: string[]) => number;
+}
+```
+
+
+License
+-------
+
+(MIT License)
+
+Copyright 2018, Microsoft
diff --git a/tools/ui/node_modules/jsonc-parser/SECURITY.md b/tools/ui/node_modules/jsonc-parser/SECURITY.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7b89984f0fb5dd204028bc525e19eefc0859f4f
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/SECURITY.md
@@ -0,0 +1,41 @@
+
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc).
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+ * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+ * Full paths of source file(s) related to the manifestation of the issue
+ * The location of the affected source code (tag/branch/commit or direct URL)
+ * Any special configuration required to reproduce the issue
+ * Step-by-step instructions to reproduce the issue
+ * Proof-of-concept or exploit code (if possible)
+ * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
+
+
\ No newline at end of file
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/impl/edit.js b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/edit.js
new file mode 100644
index 0000000000000000000000000000000000000000..4114d525b7fa2db6824ee4c3351c58aa4c6a4876
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/edit.js
@@ -0,0 +1,185 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import { format, isEOL } from './format';
+import { parseTree, findNodeAtLocation } from './parser';
+export function removeProperty(text, path, options) {
+ return setProperty(text, path, void 0, options);
+}
+export function setProperty(text, originalPath, value, options) {
+ const path = originalPath.slice();
+ const errors = [];
+ const root = parseTree(text, errors);
+ let parent = void 0;
+ let lastSegment = void 0;
+ while (path.length > 0) {
+ lastSegment = path.pop();
+ parent = findNodeAtLocation(root, path);
+ if (parent === void 0 && value !== void 0) {
+ if (typeof lastSegment === 'string') {
+ value = { [lastSegment]: value };
+ }
+ else {
+ value = [value];
+ }
+ }
+ else {
+ break;
+ }
+ }
+ if (!parent) {
+ // empty document
+ if (value === void 0) { // delete
+ throw new Error('Can not delete in empty document');
+ }
+ return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+ }
+ else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
+ const existing = findNodeAtLocation(parent, [lastSegment]);
+ if (existing !== void 0) {
+ if (value === void 0) { // delete
+ if (!existing.parent) {
+ throw new Error('Malformed AST');
+ }
+ const propertyIndex = parent.children.indexOf(existing.parent);
+ let removeBegin;
+ let removeEnd = existing.parent.offset + existing.parent.length;
+ if (propertyIndex > 0) {
+ // remove the comma of the previous node
+ let previous = parent.children[propertyIndex - 1];
+ removeBegin = previous.offset + previous.length;
+ }
+ else {
+ removeBegin = parent.offset + 1;
+ if (parent.children.length > 1) {
+ // remove the comma of the next node
+ let next = parent.children[1];
+ removeEnd = next.offset;
+ }
+ }
+ return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, options);
+ }
+ else {
+ // set value of existing property
+ return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+ }
+ }
+ else {
+ if (value === void 0) { // delete
+ return []; // property does not exist, nothing to do
+ }
+ const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+ const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
+ let edit;
+ if (index > 0) {
+ let previous = parent.children[index - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ else if (parent.children.length === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+ }
+ else {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
+ }
+ return withFormatting(text, edit, options);
+ }
+ }
+ else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
+ const insertIndex = lastSegment;
+ if (insertIndex === -1) {
+ // Insert
+ const newProperty = `${JSON.stringify(value)}`;
+ let edit;
+ if (parent.children.length === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+ }
+ else {
+ const previous = parent.children[parent.children.length - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else if (value === void 0 && parent.children.length >= 0) {
+ // Removal
+ const removalIndex = lastSegment;
+ const toRemove = parent.children[removalIndex];
+ let edit;
+ if (parent.children.length === 1) {
+ // only item
+ edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
+ }
+ else if (parent.children.length - 1 === removalIndex) {
+ // last item
+ let previous = parent.children[removalIndex - 1];
+ let offset = previous.offset + previous.length;
+ let parentEndOffset = parent.offset + parent.length;
+ edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
+ }
+ else {
+ edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else if (value !== void 0) {
+ let edit;
+ const newProperty = `${JSON.stringify(value)}`;
+ if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+ const toModify = parent.children[lastSegment];
+ edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+ }
+ else if (parent.children.length === 0 || lastSegment === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
+ }
+ else {
+ const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+ const previous = parent.children[index - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else {
+ throw new Error(`Can not ${value === void 0 ? 'remove' : (options.isArrayInsertion ? 'insert' : 'modify')} Array index ${insertIndex} as length is not sufficient`);
+ }
+ }
+ else {
+ throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
+ }
+}
+function withFormatting(text, edit, options) {
+ if (!options.formattingOptions) {
+ return [edit];
+ }
+ // apply the edit
+ let newText = applyEdit(text, edit);
+ // format the new text
+ let begin = edit.offset;
+ let end = edit.offset + edit.content.length;
+ if (edit.length === 0 || edit.content.length === 0) { // insert or remove
+ while (begin > 0 && !isEOL(newText, begin - 1)) {
+ begin--;
+ }
+ while (end < newText.length && !isEOL(newText, end)) {
+ end++;
+ }
+ }
+ const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+ // apply the formatting edits and track the begin and end offsets of the changes
+ for (let i = edits.length - 1; i >= 0; i--) {
+ const edit = edits[i];
+ newText = applyEdit(newText, edit);
+ begin = Math.min(begin, edit.offset);
+ end = Math.max(end, edit.offset + edit.length);
+ end += edit.content.length - edit.length;
+ }
+ // create a single edit with all changes
+ const editLength = text.length - (newText.length - end) - begin;
+ return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+export function applyEdit(text, edit) {
+ return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+export function isWS(text, offset) {
+ return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
+}
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/impl/format.js b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/format.js
new file mode 100644
index 0000000000000000000000000000000000000000..8663a1f385b08ddb8d2cc32bd3fc793b6751737c
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/format.js
@@ -0,0 +1,261 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import { createScanner } from './scanner';
+import { cachedSpaces, cachedBreakLinesWithSpaces, supportedEols } from './string-intern';
+export function format(documentText, range, options) {
+ let initialIndentLevel;
+ let formatText;
+ let formatTextStart;
+ let rangeStart;
+ let rangeEnd;
+ if (range) {
+ rangeStart = range.offset;
+ rangeEnd = rangeStart + range.length;
+ formatTextStart = rangeStart;
+ while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+ formatTextStart--;
+ }
+ let endOffset = rangeEnd;
+ while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+ endOffset++;
+ }
+ formatText = documentText.substring(formatTextStart, endOffset);
+ initialIndentLevel = computeIndentLevel(formatText, options);
+ }
+ else {
+ formatText = documentText;
+ initialIndentLevel = 0;
+ formatTextStart = 0;
+ rangeStart = 0;
+ rangeEnd = documentText.length;
+ }
+ const eol = getEOL(options, documentText);
+ const eolFastPathSupported = supportedEols.includes(eol);
+ let numberLineBreaks = 0;
+ let indentLevel = 0;
+ let indentValue;
+ if (options.insertSpaces) {
+ indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+ }
+ else {
+ indentValue = '\t';
+ }
+ const indentType = indentValue === '\t' ? '\t' : ' ';
+ let scanner = createScanner(formatText, false);
+ let hasError = false;
+ function newLinesAndIndent() {
+ if (numberLineBreaks > 1) {
+ return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+ }
+ const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+ if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+ return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+ }
+ if (amountOfSpaces <= 0) {
+ return eol;
+ }
+ return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+ }
+ function scanNext() {
+ let token = scanner.scan();
+ numberLineBreaks = 0;
+ while (token === 15 /* SyntaxKind.Trivia */ || token === 14 /* SyntaxKind.LineBreakTrivia */) {
+ if (token === 14 /* SyntaxKind.LineBreakTrivia */ && options.keepLines) {
+ numberLineBreaks += 1;
+ }
+ else if (token === 14 /* SyntaxKind.LineBreakTrivia */) {
+ numberLineBreaks = 1;
+ }
+ token = scanner.scan();
+ }
+ hasError = token === 16 /* SyntaxKind.Unknown */ || scanner.getTokenError() !== 0 /* ScanError.None */;
+ return token;
+ }
+ const editOperations = [];
+ function addEdit(text, startOffset, endOffset) {
+ if (!hasError && (!range || (startOffset < rangeEnd && endOffset > rangeStart)) && documentText.substring(startOffset, endOffset) !== text) {
+ editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+ }
+ }
+ let firstToken = scanNext();
+ if (options.keepLines && numberLineBreaks > 0) {
+ addEdit(repeat(eol, numberLineBreaks), 0, 0);
+ }
+ if (firstToken !== 17 /* SyntaxKind.EOF */) {
+ let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+ let initialIndent = (indentValue.length * initialIndentLevel < 20) && options.insertSpaces
+ ? cachedSpaces[indentValue.length * initialIndentLevel]
+ : repeat(indentValue, initialIndentLevel);
+ addEdit(initialIndent, formatTextStart, firstTokenStart);
+ }
+ while (firstToken !== 17 /* SyntaxKind.EOF */) {
+ let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+ let secondToken = scanNext();
+ let replaceContent = '';
+ let needsLineBreak = false;
+ while (numberLineBreaks === 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+ let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+ addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+ firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+ needsLineBreak = secondToken === 12 /* SyntaxKind.LineCommentTrivia */;
+ replaceContent = needsLineBreak ? newLinesAndIndent() : '';
+ secondToken = scanNext();
+ }
+ if (secondToken === 2 /* SyntaxKind.CloseBraceToken */) {
+ if (firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
+ indentLevel--;
+ }
+ ;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (options.keepLines) {
+ replaceContent = cachedSpaces[1];
+ }
+ }
+ else if (secondToken === 4 /* SyntaxKind.CloseBracketToken */) {
+ if (firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
+ indentLevel--;
+ }
+ ;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (options.keepLines) {
+ replaceContent = cachedSpaces[1];
+ }
+ }
+ else {
+ switch (firstToken) {
+ case 3 /* SyntaxKind.OpenBracketToken */:
+ case 1 /* SyntaxKind.OpenBraceToken */:
+ indentLevel++;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = cachedSpaces[1];
+ }
+ break;
+ case 5 /* SyntaxKind.CommaToken */:
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = cachedSpaces[1];
+ }
+ break;
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ replaceContent = newLinesAndIndent();
+ break;
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ if (numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (!needsLineBreak) {
+ replaceContent = cachedSpaces[1];
+ }
+ break;
+ case 6 /* SyntaxKind.ColonToken */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (!needsLineBreak) {
+ replaceContent = cachedSpaces[1];
+ }
+ break;
+ case 10 /* SyntaxKind.StringLiteral */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (secondToken === 6 /* SyntaxKind.ColonToken */ && !needsLineBreak) {
+ replaceContent = '';
+ }
+ break;
+ case 7 /* SyntaxKind.NullKeyword */:
+ case 8 /* SyntaxKind.TrueKeyword */:
+ case 9 /* SyntaxKind.FalseKeyword */:
+ case 11 /* SyntaxKind.NumericLiteral */:
+ case 2 /* SyntaxKind.CloseBraceToken */:
+ case 4 /* SyntaxKind.CloseBracketToken */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ if ((secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */) && !needsLineBreak) {
+ replaceContent = cachedSpaces[1];
+ }
+ else if (secondToken !== 5 /* SyntaxKind.CommaToken */ && secondToken !== 17 /* SyntaxKind.EOF */) {
+ hasError = true;
+ }
+ }
+ break;
+ case 16 /* SyntaxKind.Unknown */:
+ hasError = true;
+ break;
+ }
+ if (numberLineBreaks > 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+ replaceContent = newLinesAndIndent();
+ }
+ }
+ if (secondToken === 17 /* SyntaxKind.EOF */) {
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = options.insertFinalNewline ? eol : '';
+ }
+ }
+ const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+ addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+ firstToken = secondToken;
+ }
+ return editOperations;
+}
+function repeat(s, count) {
+ let result = '';
+ for (let i = 0; i < count; i++) {
+ result += s;
+ }
+ return result;
+}
+function computeIndentLevel(content, options) {
+ let i = 0;
+ let nChars = 0;
+ const tabSize = options.tabSize || 4;
+ while (i < content.length) {
+ let ch = content.charAt(i);
+ if (ch === cachedSpaces[1]) {
+ nChars++;
+ }
+ else if (ch === '\t') {
+ nChars += tabSize;
+ }
+ else {
+ break;
+ }
+ i++;
+ }
+ return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+ for (let i = 0; i < text.length; i++) {
+ const ch = text.charAt(i);
+ if (ch === '\r') {
+ if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
+ return '\r\n';
+ }
+ return '\r';
+ }
+ else if (ch === '\n') {
+ return '\n';
+ }
+ }
+ return (options && options.eol) || '\n';
+}
+export function isEOL(text, offset) {
+ return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/impl/parser.js b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/parser.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ebb947f32bcf5da4bd55ff140be75fb52bbe429
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/parser.js
@@ -0,0 +1,659 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import { createScanner } from './scanner';
+var ParseOptions;
+(function (ParseOptions) {
+ ParseOptions.DEFAULT = {
+ allowTrailingComma: false
+ };
+})(ParseOptions || (ParseOptions = {}));
+/**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+export function getLocation(text, position) {
+ const segments = []; // strings or numbers
+ const earlyReturnException = new Object();
+ let previousNode = undefined;
+ const previousNodeInst = {
+ value: {},
+ offset: 0,
+ length: 0,
+ type: 'object',
+ parent: undefined
+ };
+ let isAtPropertyKey = false;
+ function setPreviousNode(value, offset, length, type) {
+ previousNodeInst.value = value;
+ previousNodeInst.offset = offset;
+ previousNodeInst.length = length;
+ previousNodeInst.type = type;
+ previousNodeInst.colonOffset = undefined;
+ previousNode = previousNodeInst;
+ }
+ try {
+ visit(text, {
+ onObjectBegin: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ isAtPropertyKey = position > offset;
+ segments.push(''); // push a placeholder (will be replaced)
+ },
+ onObjectProperty: (name, offset, length) => {
+ if (position < offset) {
+ throw earlyReturnException;
+ }
+ setPreviousNode(name, offset, length, 'property');
+ segments[segments.length - 1] = name;
+ if (position <= offset + length) {
+ throw earlyReturnException;
+ }
+ },
+ onObjectEnd: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.pop();
+ },
+ onArrayBegin: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.push(0);
+ },
+ onArrayEnd: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.pop();
+ },
+ onLiteralValue: (value, offset, length) => {
+ if (position < offset) {
+ throw earlyReturnException;
+ }
+ setPreviousNode(value, offset, length, getNodeType(value));
+ if (position <= offset + length) {
+ throw earlyReturnException;
+ }
+ },
+ onSeparator: (sep, offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ if (sep === ':' && previousNode && previousNode.type === 'property') {
+ previousNode.colonOffset = offset;
+ isAtPropertyKey = false;
+ previousNode = undefined;
+ }
+ else if (sep === ',') {
+ const last = segments[segments.length - 1];
+ if (typeof last === 'number') {
+ segments[segments.length - 1] = last + 1;
+ }
+ else {
+ isAtPropertyKey = true;
+ segments[segments.length - 1] = '';
+ }
+ previousNode = undefined;
+ }
+ }
+ });
+ }
+ catch (e) {
+ if (e !== earlyReturnException) {
+ throw e;
+ }
+ }
+ return {
+ path: segments,
+ previousNode,
+ isAtPropertyKey,
+ matches: (pattern) => {
+ let k = 0;
+ for (let i = 0; k < pattern.length && i < segments.length; i++) {
+ if (pattern[k] === segments[i] || pattern[k] === '*') {
+ k++;
+ }
+ else if (pattern[k] !== '**') {
+ return false;
+ }
+ }
+ return k === pattern.length;
+ }
+ };
+}
+/**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore always check the errors list to find out if the input was valid.
+ */
+export function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+ let currentProperty = null;
+ let currentParent = [];
+ const previousParents = [];
+ function onValue(value) {
+ if (Array.isArray(currentParent)) {
+ currentParent.push(value);
+ }
+ else if (currentProperty !== null) {
+ currentParent[currentProperty] = value;
+ }
+ }
+ const visitor = {
+ onObjectBegin: () => {
+ const object = {};
+ onValue(object);
+ previousParents.push(currentParent);
+ currentParent = object;
+ currentProperty = null;
+ },
+ onObjectProperty: (name) => {
+ currentProperty = name;
+ },
+ onObjectEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onArrayBegin: () => {
+ const array = [];
+ onValue(array);
+ previousParents.push(currentParent);
+ currentParent = array;
+ currentProperty = null;
+ },
+ onArrayEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onLiteralValue: onValue,
+ onError: (error, offset, length) => {
+ errors.push({ error, offset, length });
+ }
+ };
+ visit(text, visitor, options);
+ return currentParent[0];
+}
+/**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+export function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+ let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
+ function ensurePropertyComplete(endOffset) {
+ if (currentParent.type === 'property') {
+ currentParent.length = endOffset - currentParent.offset;
+ currentParent = currentParent.parent;
+ }
+ }
+ function onValue(valueNode) {
+ currentParent.children.push(valueNode);
+ return valueNode;
+ }
+ const visitor = {
+ onObjectBegin: (offset) => {
+ currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
+ },
+ onObjectProperty: (name, offset, length) => {
+ currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
+ currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
+ },
+ onObjectEnd: (offset, length) => {
+ ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
+ currentParent.length = offset + length - currentParent.offset;
+ currentParent = currentParent.parent;
+ ensurePropertyComplete(offset + length);
+ },
+ onArrayBegin: (offset, length) => {
+ currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
+ },
+ onArrayEnd: (offset, length) => {
+ currentParent.length = offset + length - currentParent.offset;
+ currentParent = currentParent.parent;
+ ensurePropertyComplete(offset + length);
+ },
+ onLiteralValue: (value, offset, length) => {
+ onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+ ensurePropertyComplete(offset + length);
+ },
+ onSeparator: (sep, offset, length) => {
+ if (currentParent.type === 'property') {
+ if (sep === ':') {
+ currentParent.colonOffset = offset;
+ }
+ else if (sep === ',') {
+ ensurePropertyComplete(offset);
+ }
+ }
+ },
+ onError: (error, offset, length) => {
+ errors.push({ error, offset, length });
+ }
+ };
+ visit(text, visitor, options);
+ const result = currentParent.children[0];
+ if (result) {
+ delete result.parent;
+ }
+ return result;
+}
+/**
+ * Finds the node at the given path in a JSON DOM.
+ */
+export function findNodeAtLocation(root, path) {
+ if (!root) {
+ return undefined;
+ }
+ let node = root;
+ for (let segment of path) {
+ if (typeof segment === 'string') {
+ if (node.type !== 'object' || !Array.isArray(node.children)) {
+ return undefined;
+ }
+ let found = false;
+ for (const propertyNode of node.children) {
+ if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+ node = propertyNode.children[1];
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ return undefined;
+ }
+ }
+ else {
+ const index = segment;
+ if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+ return undefined;
+ }
+ node = node.children[index];
+ }
+ }
+ return node;
+}
+/**
+ * Gets the JSON path of the given JSON DOM node
+ */
+export function getNodePath(node) {
+ if (!node.parent || !node.parent.children) {
+ return [];
+ }
+ const path = getNodePath(node.parent);
+ if (node.parent.type === 'property') {
+ const key = node.parent.children[0].value;
+ path.push(key);
+ }
+ else if (node.parent.type === 'array') {
+ const index = node.parent.children.indexOf(node);
+ if (index !== -1) {
+ path.push(index);
+ }
+ }
+ return path;
+}
+/**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+export function getNodeValue(node) {
+ switch (node.type) {
+ case 'array':
+ return node.children.map(getNodeValue);
+ case 'object':
+ const obj = Object.create(null);
+ for (let prop of node.children) {
+ const valueNode = prop.children[1];
+ if (valueNode) {
+ obj[prop.children[0].value] = getNodeValue(valueNode);
+ }
+ }
+ return obj;
+ case 'null':
+ case 'string':
+ case 'number':
+ case 'boolean':
+ return node.value;
+ default:
+ return undefined;
+ }
+}
+export function contains(node, offset, includeRightBound = false) {
+ return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
+}
+/**
+ * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+export function findNodeAtOffset(node, offset, includeRightBound = false) {
+ if (contains(node, offset, includeRightBound)) {
+ const children = node.children;
+ if (Array.isArray(children)) {
+ for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+ const item = findNodeAtOffset(children[i], offset, includeRightBound);
+ if (item) {
+ return item;
+ }
+ }
+ }
+ return node;
+ }
+ return undefined;
+}
+/**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+export function visit(text, visitor, options = ParseOptions.DEFAULT) {
+ const _scanner = createScanner(text, false);
+ // Important: Only pass copies of this to visitor functions to prevent accidental modification, and
+ // to not affect visitor functions which stored a reference to a previous JSONPath
+ const _jsonPath = [];
+ // Depth of onXXXBegin() callbacks suppressed. onXXXEnd() decrements this if it isn't 0 already.
+ // Callbacks are only called when this value is 0.
+ let suppressedCallbacks = 0;
+ function toNoArgVisit(visitFunction) {
+ return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ function toOneArgVisit(visitFunction) {
+ return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ function toOneArgVisitWithPath(visitFunction) {
+ return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+ }
+ function toBeginVisit(visitFunction) {
+ return visitFunction ?
+ () => {
+ if (suppressedCallbacks > 0) {
+ suppressedCallbacks++;
+ }
+ else {
+ let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+ if (cbReturn === false) {
+ suppressedCallbacks = 1;
+ }
+ }
+ }
+ : () => true;
+ }
+ function toEndVisit(visitFunction) {
+ return visitFunction ?
+ () => {
+ if (suppressedCallbacks > 0) {
+ suppressedCallbacks--;
+ }
+ if (suppressedCallbacks === 0) {
+ visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+ }
+ }
+ : () => true;
+ }
+ const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+ const disallowComments = options && options.disallowComments;
+ const allowTrailingComma = options && options.allowTrailingComma;
+ function scanNext() {
+ while (true) {
+ const token = _scanner.scan();
+ switch (_scanner.getTokenError()) {
+ case 4 /* ScanError.InvalidUnicode */:
+ handleError(14 /* ParseErrorCode.InvalidUnicode */);
+ break;
+ case 5 /* ScanError.InvalidEscapeCharacter */:
+ handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
+ break;
+ case 3 /* ScanError.UnexpectedEndOfNumber */:
+ handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
+ break;
+ case 1 /* ScanError.UnexpectedEndOfComment */:
+ if (!disallowComments) {
+ handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
+ }
+ break;
+ case 2 /* ScanError.UnexpectedEndOfString */:
+ handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
+ break;
+ case 6 /* ScanError.InvalidCharacter */:
+ handleError(16 /* ParseErrorCode.InvalidCharacter */);
+ break;
+ }
+ switch (token) {
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ if (disallowComments) {
+ handleError(10 /* ParseErrorCode.InvalidCommentToken */);
+ }
+ else {
+ onComment();
+ }
+ break;
+ case 16 /* SyntaxKind.Unknown */:
+ handleError(1 /* ParseErrorCode.InvalidSymbol */);
+ break;
+ case 15 /* SyntaxKind.Trivia */:
+ case 14 /* SyntaxKind.LineBreakTrivia */:
+ break;
+ default:
+ return token;
+ }
+ }
+ }
+ function handleError(error, skipUntilAfter = [], skipUntil = []) {
+ onError(error);
+ if (skipUntilAfter.length + skipUntil.length > 0) {
+ let token = _scanner.getToken();
+ while (token !== 17 /* SyntaxKind.EOF */) {
+ if (skipUntilAfter.indexOf(token) !== -1) {
+ scanNext();
+ break;
+ }
+ else if (skipUntil.indexOf(token) !== -1) {
+ break;
+ }
+ token = scanNext();
+ }
+ }
+ }
+ function parseString(isValue) {
+ const value = _scanner.getTokenValue();
+ if (isValue) {
+ onLiteralValue(value);
+ }
+ else {
+ onObjectProperty(value);
+ // add property name afterwards
+ _jsonPath.push(value);
+ }
+ scanNext();
+ return true;
+ }
+ function parseLiteral() {
+ switch (_scanner.getToken()) {
+ case 11 /* SyntaxKind.NumericLiteral */:
+ const tokenValue = _scanner.getTokenValue();
+ let value = Number(tokenValue);
+ if (isNaN(value)) {
+ handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
+ value = 0;
+ }
+ onLiteralValue(value);
+ break;
+ case 7 /* SyntaxKind.NullKeyword */:
+ onLiteralValue(null);
+ break;
+ case 8 /* SyntaxKind.TrueKeyword */:
+ onLiteralValue(true);
+ break;
+ case 9 /* SyntaxKind.FalseKeyword */:
+ onLiteralValue(false);
+ break;
+ default:
+ return false;
+ }
+ scanNext();
+ return true;
+ }
+ function parseProperty() {
+ if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
+ handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ return false;
+ }
+ parseString(false);
+ if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
+ onSeparator(':');
+ scanNext(); // consume colon
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ }
+ else {
+ handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ _jsonPath.pop(); // remove processed property name
+ return true;
+ }
+ function parseObject() {
+ onObjectBegin();
+ scanNext(); // consume open brace
+ let needsComma = false;
+ while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+ if (!needsComma) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ }
+ onSeparator(',');
+ scanNext(); // consume comma
+ if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
+ break;
+ }
+ }
+ else if (needsComma) {
+ handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+ }
+ if (!parseProperty()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ needsComma = true;
+ }
+ onObjectEnd();
+ if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
+ handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
+ }
+ else {
+ scanNext(); // consume close brace
+ }
+ return true;
+ }
+ function parseArray() {
+ onArrayBegin();
+ scanNext(); // consume open bracket
+ let isFirstElement = true;
+ let needsComma = false;
+ while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+ if (!needsComma) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ }
+ onSeparator(',');
+ scanNext(); // consume comma
+ if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
+ break;
+ }
+ }
+ else if (needsComma) {
+ handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+ }
+ if (isFirstElement) {
+ _jsonPath.push(0);
+ isFirstElement = false;
+ }
+ else {
+ _jsonPath[_jsonPath.length - 1]++;
+ }
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ needsComma = true;
+ }
+ onArrayEnd();
+ if (!isFirstElement) {
+ _jsonPath.pop(); // remove array index
+ }
+ if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
+ handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
+ }
+ else {
+ scanNext(); // consume close bracket
+ }
+ return true;
+ }
+ function parseValue() {
+ switch (_scanner.getToken()) {
+ case 3 /* SyntaxKind.OpenBracketToken */:
+ return parseArray();
+ case 1 /* SyntaxKind.OpenBraceToken */:
+ return parseObject();
+ case 10 /* SyntaxKind.StringLiteral */:
+ return parseString(true);
+ default:
+ return parseLiteral();
+ }
+ }
+ scanNext();
+ if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
+ if (options.allowEmptyContent) {
+ return true;
+ }
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ return false;
+ }
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ return false;
+ }
+ if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
+ }
+ return true;
+}
+/**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+export function stripComments(text, replaceCh) {
+ let _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
+ do {
+ pos = _scanner.getPosition();
+ kind = _scanner.scan();
+ switch (kind) {
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ case 17 /* SyntaxKind.EOF */:
+ if (offset !== pos) {
+ parts.push(text.substring(offset, pos));
+ }
+ if (replaceCh !== undefined) {
+ parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+ }
+ offset = _scanner.getPosition();
+ break;
+ }
+ } while (kind !== 17 /* SyntaxKind.EOF */);
+ return parts.join('');
+}
+export function getNodeType(value) {
+ switch (typeof value) {
+ case 'boolean': return 'boolean';
+ case 'number': return 'number';
+ case 'string': return 'string';
+ case 'object': {
+ if (!value) {
+ return 'null';
+ }
+ else if (Array.isArray(value)) {
+ return 'array';
+ }
+ return 'object';
+ }
+ default: return 'null';
+ }
+}
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/impl/scanner.js b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/scanner.js
new file mode 100644
index 0000000000000000000000000000000000000000..e84942c122b7bca38dddd177a519d7a17ad4fcef
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/scanner.js
@@ -0,0 +1,443 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+/**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+export function createScanner(text, ignoreTrivia = false) {
+ const len = text.length;
+ let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;
+ function scanHexDigits(count, exact) {
+ let digits = 0;
+ let value = 0;
+ while (digits < count || !exact) {
+ let ch = text.charCodeAt(pos);
+ if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
+ value = value * 16 + ch - 48 /* CharacterCodes._0 */;
+ }
+ else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
+ value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;
+ }
+ else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
+ value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;
+ }
+ else {
+ break;
+ }
+ pos++;
+ digits++;
+ }
+ if (digits < count) {
+ value = -1;
+ }
+ return value;
+ }
+ function setPosition(newPosition) {
+ pos = newPosition;
+ value = '';
+ tokenOffset = 0;
+ token = 16 /* SyntaxKind.Unknown */;
+ scanError = 0 /* ScanError.None */;
+ }
+ function scanNumber() {
+ let start = pos;
+ if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
+ pos++;
+ }
+ else {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ }
+ if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
+ pos++;
+ if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ }
+ else {
+ scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+ return text.substring(start, pos);
+ }
+ }
+ let end = pos;
+ if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
+ pos++;
+ if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
+ pos++;
+ }
+ if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ end = pos;
+ }
+ else {
+ scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+ }
+ }
+ return text.substring(start, end);
+ }
+ function scanString() {
+ let result = '', start = pos;
+ while (true) {
+ if (pos >= len) {
+ result += text.substring(start, pos);
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ const ch = text.charCodeAt(pos);
+ if (ch === 34 /* CharacterCodes.doubleQuote */) {
+ result += text.substring(start, pos);
+ pos++;
+ break;
+ }
+ if (ch === 92 /* CharacterCodes.backslash */) {
+ result += text.substring(start, pos);
+ pos++;
+ if (pos >= len) {
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ const ch2 = text.charCodeAt(pos++);
+ switch (ch2) {
+ case 34 /* CharacterCodes.doubleQuote */:
+ result += '\"';
+ break;
+ case 92 /* CharacterCodes.backslash */:
+ result += '\\';
+ break;
+ case 47 /* CharacterCodes.slash */:
+ result += '/';
+ break;
+ case 98 /* CharacterCodes.b */:
+ result += '\b';
+ break;
+ case 102 /* CharacterCodes.f */:
+ result += '\f';
+ break;
+ case 110 /* CharacterCodes.n */:
+ result += '\n';
+ break;
+ case 114 /* CharacterCodes.r */:
+ result += '\r';
+ break;
+ case 116 /* CharacterCodes.t */:
+ result += '\t';
+ break;
+ case 117 /* CharacterCodes.u */:
+ const ch3 = scanHexDigits(4, true);
+ if (ch3 >= 0) {
+ result += String.fromCharCode(ch3);
+ }
+ else {
+ scanError = 4 /* ScanError.InvalidUnicode */;
+ }
+ break;
+ default:
+ scanError = 5 /* ScanError.InvalidEscapeCharacter */;
+ }
+ start = pos;
+ continue;
+ }
+ if (ch >= 0 && ch <= 0x1f) {
+ if (isLineBreak(ch)) {
+ result += text.substring(start, pos);
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ else {
+ scanError = 6 /* ScanError.InvalidCharacter */;
+ // mark as error but continue with string
+ }
+ }
+ pos++;
+ }
+ return result;
+ }
+ function scanNext() {
+ value = '';
+ scanError = 0 /* ScanError.None */;
+ tokenOffset = pos;
+ lineStartOffset = lineNumber;
+ prevTokenLineStartOffset = tokenLineStartOffset;
+ if (pos >= len) {
+ // at the end
+ tokenOffset = len;
+ return token = 17 /* SyntaxKind.EOF */;
+ }
+ let code = text.charCodeAt(pos);
+ // trivia: whitespace
+ if (isWhiteSpace(code)) {
+ do {
+ pos++;
+ value += String.fromCharCode(code);
+ code = text.charCodeAt(pos);
+ } while (isWhiteSpace(code));
+ return token = 15 /* SyntaxKind.Trivia */;
+ }
+ // trivia: newlines
+ if (isLineBreak(code)) {
+ pos++;
+ value += String.fromCharCode(code);
+ if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
+ pos++;
+ value += '\n';
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ return token = 14 /* SyntaxKind.LineBreakTrivia */;
+ }
+ switch (code) {
+ // tokens: []{}:,
+ case 123 /* CharacterCodes.openBrace */:
+ pos++;
+ return token = 1 /* SyntaxKind.OpenBraceToken */;
+ case 125 /* CharacterCodes.closeBrace */:
+ pos++;
+ return token = 2 /* SyntaxKind.CloseBraceToken */;
+ case 91 /* CharacterCodes.openBracket */:
+ pos++;
+ return token = 3 /* SyntaxKind.OpenBracketToken */;
+ case 93 /* CharacterCodes.closeBracket */:
+ pos++;
+ return token = 4 /* SyntaxKind.CloseBracketToken */;
+ case 58 /* CharacterCodes.colon */:
+ pos++;
+ return token = 6 /* SyntaxKind.ColonToken */;
+ case 44 /* CharacterCodes.comma */:
+ pos++;
+ return token = 5 /* SyntaxKind.CommaToken */;
+ // strings
+ case 34 /* CharacterCodes.doubleQuote */:
+ pos++;
+ value = scanString();
+ return token = 10 /* SyntaxKind.StringLiteral */;
+ // comments
+ case 47 /* CharacterCodes.slash */:
+ const start = pos - 1;
+ // Single-line comment
+ if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+ pos += 2;
+ while (pos < len) {
+ if (isLineBreak(text.charCodeAt(pos))) {
+ break;
+ }
+ pos++;
+ }
+ value = text.substring(start, pos);
+ return token = 12 /* SyntaxKind.LineCommentTrivia */;
+ }
+ // Multi-line comment
+ if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
+ pos += 2;
+ const safeLength = len - 1; // For lookahead.
+ let commentClosed = false;
+ while (pos < safeLength) {
+ const ch = text.charCodeAt(pos);
+ if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+ pos += 2;
+ commentClosed = true;
+ break;
+ }
+ pos++;
+ if (isLineBreak(ch)) {
+ if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
+ pos++;
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ }
+ }
+ if (!commentClosed) {
+ pos++;
+ scanError = 1 /* ScanError.UnexpectedEndOfComment */;
+ }
+ value = text.substring(start, pos);
+ return token = 13 /* SyntaxKind.BlockCommentTrivia */;
+ }
+ // just a single slash
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16 /* SyntaxKind.Unknown */;
+ // numbers
+ case 45 /* CharacterCodes.minus */:
+ value += String.fromCharCode(code);
+ pos++;
+ if (pos === len || !isDigit(text.charCodeAt(pos))) {
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ // found a minus, followed by a number so
+ // we fall through to proceed with scanning
+ // numbers
+ case 48 /* CharacterCodes._0 */:
+ case 49 /* CharacterCodes._1 */:
+ case 50 /* CharacterCodes._2 */:
+ case 51 /* CharacterCodes._3 */:
+ case 52 /* CharacterCodes._4 */:
+ case 53 /* CharacterCodes._5 */:
+ case 54 /* CharacterCodes._6 */:
+ case 55 /* CharacterCodes._7 */:
+ case 56 /* CharacterCodes._8 */:
+ case 57 /* CharacterCodes._9 */:
+ value += scanNumber();
+ return token = 11 /* SyntaxKind.NumericLiteral */;
+ // literals and unknown symbols
+ default:
+ // is a literal? Read the full word.
+ while (pos < len && isUnknownContentCharacter(code)) {
+ pos++;
+ code = text.charCodeAt(pos);
+ }
+ if (tokenOffset !== pos) {
+ value = text.substring(tokenOffset, pos);
+ // keywords: true, false, null
+ switch (value) {
+ case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
+ case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
+ case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
+ }
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ // some
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ }
+ function isUnknownContentCharacter(code) {
+ if (isWhiteSpace(code) || isLineBreak(code)) {
+ return false;
+ }
+ switch (code) {
+ case 125 /* CharacterCodes.closeBrace */:
+ case 93 /* CharacterCodes.closeBracket */:
+ case 123 /* CharacterCodes.openBrace */:
+ case 91 /* CharacterCodes.openBracket */:
+ case 34 /* CharacterCodes.doubleQuote */:
+ case 58 /* CharacterCodes.colon */:
+ case 44 /* CharacterCodes.comma */:
+ case 47 /* CharacterCodes.slash */:
+ return false;
+ }
+ return true;
+ }
+ function scanNextNonTrivia() {
+ let result;
+ do {
+ result = scanNext();
+ } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
+ return result;
+ }
+ return {
+ setPosition: setPosition,
+ getPosition: () => pos,
+ scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+ getToken: () => token,
+ getTokenValue: () => value,
+ getTokenOffset: () => tokenOffset,
+ getTokenLength: () => pos - tokenOffset,
+ getTokenStartLine: () => lineStartOffset,
+ getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+ getTokenError: () => scanError,
+ };
+}
+function isWhiteSpace(ch) {
+ return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;
+}
+function isLineBreak(ch) {
+ return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;
+}
+function isDigit(ch) {
+ return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
+}
+var CharacterCodes;
+(function (CharacterCodes) {
+ CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+ CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+ CharacterCodes[CharacterCodes["space"] = 32] = "space";
+ CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+ CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+ CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+ CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+ CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+ CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+ CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+ CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+ CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+ CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+ CharacterCodes[CharacterCodes["a"] = 97] = "a";
+ CharacterCodes[CharacterCodes["b"] = 98] = "b";
+ CharacterCodes[CharacterCodes["c"] = 99] = "c";
+ CharacterCodes[CharacterCodes["d"] = 100] = "d";
+ CharacterCodes[CharacterCodes["e"] = 101] = "e";
+ CharacterCodes[CharacterCodes["f"] = 102] = "f";
+ CharacterCodes[CharacterCodes["g"] = 103] = "g";
+ CharacterCodes[CharacterCodes["h"] = 104] = "h";
+ CharacterCodes[CharacterCodes["i"] = 105] = "i";
+ CharacterCodes[CharacterCodes["j"] = 106] = "j";
+ CharacterCodes[CharacterCodes["k"] = 107] = "k";
+ CharacterCodes[CharacterCodes["l"] = 108] = "l";
+ CharacterCodes[CharacterCodes["m"] = 109] = "m";
+ CharacterCodes[CharacterCodes["n"] = 110] = "n";
+ CharacterCodes[CharacterCodes["o"] = 111] = "o";
+ CharacterCodes[CharacterCodes["p"] = 112] = "p";
+ CharacterCodes[CharacterCodes["q"] = 113] = "q";
+ CharacterCodes[CharacterCodes["r"] = 114] = "r";
+ CharacterCodes[CharacterCodes["s"] = 115] = "s";
+ CharacterCodes[CharacterCodes["t"] = 116] = "t";
+ CharacterCodes[CharacterCodes["u"] = 117] = "u";
+ CharacterCodes[CharacterCodes["v"] = 118] = "v";
+ CharacterCodes[CharacterCodes["w"] = 119] = "w";
+ CharacterCodes[CharacterCodes["x"] = 120] = "x";
+ CharacterCodes[CharacterCodes["y"] = 121] = "y";
+ CharacterCodes[CharacterCodes["z"] = 122] = "z";
+ CharacterCodes[CharacterCodes["A"] = 65] = "A";
+ CharacterCodes[CharacterCodes["B"] = 66] = "B";
+ CharacterCodes[CharacterCodes["C"] = 67] = "C";
+ CharacterCodes[CharacterCodes["D"] = 68] = "D";
+ CharacterCodes[CharacterCodes["E"] = 69] = "E";
+ CharacterCodes[CharacterCodes["F"] = 70] = "F";
+ CharacterCodes[CharacterCodes["G"] = 71] = "G";
+ CharacterCodes[CharacterCodes["H"] = 72] = "H";
+ CharacterCodes[CharacterCodes["I"] = 73] = "I";
+ CharacterCodes[CharacterCodes["J"] = 74] = "J";
+ CharacterCodes[CharacterCodes["K"] = 75] = "K";
+ CharacterCodes[CharacterCodes["L"] = 76] = "L";
+ CharacterCodes[CharacterCodes["M"] = 77] = "M";
+ CharacterCodes[CharacterCodes["N"] = 78] = "N";
+ CharacterCodes[CharacterCodes["O"] = 79] = "O";
+ CharacterCodes[CharacterCodes["P"] = 80] = "P";
+ CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+ CharacterCodes[CharacterCodes["R"] = 82] = "R";
+ CharacterCodes[CharacterCodes["S"] = 83] = "S";
+ CharacterCodes[CharacterCodes["T"] = 84] = "T";
+ CharacterCodes[CharacterCodes["U"] = 85] = "U";
+ CharacterCodes[CharacterCodes["V"] = 86] = "V";
+ CharacterCodes[CharacterCodes["W"] = 87] = "W";
+ CharacterCodes[CharacterCodes["X"] = 88] = "X";
+ CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+ CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+ CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+ CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+ CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+ CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+ CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+ CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+ CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+ CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+ CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+ CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+ CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+ CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+ CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+ CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+ CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/impl/string-intern.js b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
new file mode 100644
index 0000000000000000000000000000000000000000..2794e2b39325539833035e7a140de17df8b28e93
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/impl/string-intern.js
@@ -0,0 +1,29 @@
+export const cachedSpaces = new Array(20).fill(0).map((_, index) => {
+ return ' '.repeat(index);
+});
+const maxCachedValues = 200;
+export const cachedBreakLinesWithSpaces = {
+ ' ': {
+ '\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\n' + ' '.repeat(index);
+ }),
+ '\r': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r' + ' '.repeat(index);
+ }),
+ '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r\n' + ' '.repeat(index);
+ }),
+ },
+ '\t': {
+ '\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\n' + '\t'.repeat(index);
+ }),
+ '\r': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r' + '\t'.repeat(index);
+ }),
+ '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r\n' + '\t'.repeat(index);
+ }),
+ }
+};
+export const supportedEols = ['\n', '\r', '\r\n'];
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/main.d.ts b/tools/ui/node_modules/jsonc-parser/lib/esm/main.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66c1691fde24ede6a90f482123a712961f6499e4
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/main.d.ts
@@ -0,0 +1,351 @@
+/**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+export declare const createScanner: (text: string, ignoreTrivia?: boolean) => JSONScanner;
+export declare const enum ScanError {
+ None = 0,
+ UnexpectedEndOfComment = 1,
+ UnexpectedEndOfString = 2,
+ UnexpectedEndOfNumber = 3,
+ InvalidUnicode = 4,
+ InvalidEscapeCharacter = 5,
+ InvalidCharacter = 6
+}
+export declare const enum SyntaxKind {
+ OpenBraceToken = 1,
+ CloseBraceToken = 2,
+ OpenBracketToken = 3,
+ CloseBracketToken = 4,
+ CommaToken = 5,
+ ColonToken = 6,
+ NullKeyword = 7,
+ TrueKeyword = 8,
+ FalseKeyword = 9,
+ StringLiteral = 10,
+ NumericLiteral = 11,
+ LineCommentTrivia = 12,
+ BlockCommentTrivia = 13,
+ LineBreakTrivia = 14,
+ Trivia = 15,
+ Unknown = 16,
+ EOF = 17
+}
+/**
+ * The scanner object, representing a JSON scanner at a position in the input string.
+ */
+export interface JSONScanner {
+ /**
+ * Sets the scan position to a new offset. A call to 'scan' is needed to get the first token.
+ */
+ setPosition(pos: number): void;
+ /**
+ * Read the next token. Returns the token code.
+ */
+ scan(): SyntaxKind;
+ /**
+ * Returns the zero-based current scan position, which is after the last read token.
+ */
+ getPosition(): number;
+ /**
+ * Returns the last read token.
+ */
+ getToken(): SyntaxKind;
+ /**
+ * Returns the last read token value. The value for strings is the decoded string content. For numbers it's of type number, for boolean it's true or false.
+ */
+ getTokenValue(): string;
+ /**
+ * The zero-based start offset of the last read token.
+ */
+ getTokenOffset(): number;
+ /**
+ * The length of the last read token.
+ */
+ getTokenLength(): number;
+ /**
+ * The zero-based start line number of the last read token.
+ */
+ getTokenStartLine(): number;
+ /**
+ * The zero-based start character (column) of the last read token.
+ */
+ getTokenStartCharacter(): number;
+ /**
+ * An error code of the last scan.
+ */
+ getTokenError(): ScanError;
+}
+/**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+export declare const getLocation: (text: string, position: number) => Location;
+/**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore, always check the errors list to find out if the input was valid.
+ */
+export declare const parse: (text: string, errors?: ParseError[], options?: ParseOptions) => any;
+/**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+export declare const parseTree: (text: string, errors?: ParseError[], options?: ParseOptions) => Node | undefined;
+/**
+ * Finds the node at the given path in a JSON DOM.
+ */
+export declare const findNodeAtLocation: (root: Node, path: JSONPath) => Node | undefined;
+/**
+ * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+export declare const findNodeAtOffset: (root: Node, offset: number, includeRightBound?: boolean) => Node | undefined;
+/**
+ * Gets the JSON path of the given JSON DOM node
+ */
+export declare const getNodePath: (node: Node) => JSONPath;
+/**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+export declare const getNodeValue: (node: Node) => any;
+/**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+export declare const visit: (text: string, visitor: JSONVisitor, options?: ParseOptions) => any;
+/**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+export declare const stripComments: (text: string, replaceCh?: string) => string;
+export interface ParseError {
+ error: ParseErrorCode;
+ offset: number;
+ length: number;
+}
+export declare const enum ParseErrorCode {
+ InvalidSymbol = 1,
+ InvalidNumberFormat = 2,
+ PropertyNameExpected = 3,
+ ValueExpected = 4,
+ ColonExpected = 5,
+ CommaExpected = 6,
+ CloseBraceExpected = 7,
+ CloseBracketExpected = 8,
+ EndOfFileExpected = 9,
+ InvalidCommentToken = 10,
+ UnexpectedEndOfComment = 11,
+ UnexpectedEndOfString = 12,
+ UnexpectedEndOfNumber = 13,
+ InvalidUnicode = 14,
+ InvalidEscapeCharacter = 15,
+ InvalidCharacter = 16
+}
+export declare function printParseErrorCode(code: ParseErrorCode): "InvalidSymbol" | "InvalidNumberFormat" | "PropertyNameExpected" | "ValueExpected" | "ColonExpected" | "CommaExpected" | "CloseBraceExpected" | "CloseBracketExpected" | "EndOfFileExpected" | "InvalidCommentToken" | "UnexpectedEndOfComment" | "UnexpectedEndOfString" | "UnexpectedEndOfNumber" | "InvalidUnicode" | "InvalidEscapeCharacter" | "InvalidCharacter" | "";
+export type NodeType = 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
+export interface Node {
+ readonly type: NodeType;
+ readonly value?: any;
+ readonly offset: number;
+ readonly length: number;
+ readonly colonOffset?: number;
+ readonly parent?: Node;
+ readonly children?: Node[];
+}
+/**
+ * A {@linkcode JSONPath} segment. Either a string representing an object property name
+ * or a number (starting at 0) for array indices.
+ */
+export type Segment = string | number;
+export type JSONPath = Segment[];
+export interface Location {
+ /**
+ * The previous property key or literal value (string, number, boolean or null) or undefined.
+ */
+ previousNode?: Node;
+ /**
+ * The path describing the location in the JSON document. The path consists of a sequence of strings
+ * representing an object property or numbers for array indices.
+ */
+ path: JSONPath;
+ /**
+ * Matches the locations path against a pattern consisting of strings (for properties) and numbers (for array indices).
+ * '*' will match a single segment of any property name or index.
+ * '**' will match a sequence of segments of any property name or index, or no segment.
+ */
+ matches: (patterns: JSONPath) => boolean;
+ /**
+ * If set, the location's offset is at a property key.
+ */
+ isAtPropertyKey: boolean;
+}
+export interface ParseOptions {
+ disallowComments?: boolean;
+ allowTrailingComma?: boolean;
+ allowEmptyContent?: boolean;
+}
+/**
+ * Visitor called by {@linkcode visit} when parsing JSON.
+ *
+ * The visitor functions have the following common parameters:
+ * - `offset`: Global offset within the JSON document, starting at 0
+ * - `startLine`: Line number, starting at 0
+ * - `startCharacter`: Start character (column) within the current line, starting at 0
+ *
+ * Additionally some functions have a `pathSupplier` parameter which can be used to obtain the
+ * current `JSONPath` within the document.
+ */
+export interface JSONVisitor {
+ /**
+ * Invoked when an open brace is encountered and an object is started. The offset and length represent the location of the open brace.
+ * When `false` is returned, the object properties will not be visited.
+ */
+ onObjectBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => boolean | void;
+ /**
+ * Invoked when a property is encountered. The offset and length represent the location of the property name.
+ * The `JSONPath` created by the `pathSupplier` refers to the enclosing JSON object, it does not include the
+ * property name yet.
+ */
+ onObjectProperty?: (property: string, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a closing brace is encountered and an object is completed. The offset and length represent the location of the closing brace.
+ */
+ onObjectEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when an open bracket is encountered. The offset and length represent the location of the open bracket.
+ * When `false` is returned, the array items will not be visited.
+ */
+ onArrayBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => boolean | void;
+ /**
+ * Invoked when a closing bracket is encountered. The offset and length represent the location of the closing bracket.
+ */
+ onArrayEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when a literal value is encountered. The offset and length represent the location of the literal value.
+ */
+ onLiteralValue?: (value: any, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a comma or colon separator is encountered. The offset and length represent the location of the separator.
+ */
+ onSeparator?: (character: string, offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * When comments are allowed, invoked when a line or block comment is encountered. The offset and length represent the location of the comment.
+ */
+ onComment?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked on an error.
+ */
+ onError?: (error: ParseErrorCode, offset: number, length: number, startLine: number, startCharacter: number) => void;
+}
+/**
+ * An edit result describes a textual edit operation. It is the result of a {@linkcode format} and {@linkcode modify} operation.
+ * It consist of one or more edits describing insertions, replacements or removals of text segments.
+ * * The offsets of the edits refer to the original state of the document.
+ * * No two edits change or remove the same range of text in the original document.
+ * * Multiple edits can have the same offset if they are multiple inserts, or an insert followed by a remove or replace.
+ * * The order in the array defines which edit is applied first.
+ * To apply an edit result use {@linkcode applyEdits}.
+ * In general multiple EditResults must not be concatenated because they might impact each other, producing incorrect or malformed JSON data.
+ */
+export type EditResult = Edit[];
+/**
+ * Represents a text modification
+ */
+export interface Edit {
+ /**
+ * The start offset of the modification.
+ */
+ offset: number;
+ /**
+ * The length of the modification. Must not be negative. Empty length represents an *insert*.
+ */
+ length: number;
+ /**
+ * The new content. Empty content represents a *remove*.
+ */
+ content: string;
+}
+/**
+ * A text range in the document
+*/
+export interface Range {
+ /**
+ * The start offset of the range.
+ */
+ offset: number;
+ /**
+ * The length of the range. Must not be negative.
+ */
+ length: number;
+}
+/**
+ * Options used by {@linkcode format} when computing the formatting edit operations
+ */
+export interface FormattingOptions {
+ /**
+ * If indentation is based on spaces (`insertSpaces` = true), the number of spaces that make an indent.
+ */
+ tabSize?: number;
+ /**
+ * Is indentation based on spaces?
+ */
+ insertSpaces?: boolean;
+ /**
+ * The default 'end of line' character. If not set, '\n' is used as default.
+ */
+ eol?: string;
+ /**
+ * If set, will add a new line at the end of the document.
+ */
+ insertFinalNewline?: boolean;
+ /**
+ * If true, will keep line positions as is in the formatting
+ */
+ keepLines?: boolean;
+}
+/**
+ * Computes the edit operations needed to format a JSON document.
+ *
+ * @param documentText The input text
+ * @param range The range to format or `undefined` to format the full content
+ * @param options The formatting options
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export declare function format(documentText: string, range: Range | undefined, options: FormattingOptions): EditResult;
+/**
+ * Options used by {@linkcode modify} when computing the modification edit operations
+ */
+export interface ModificationOptions {
+ /**
+ * Formatting options. If undefined, the newly inserted code will be inserted unformatted.
+ */
+ formattingOptions?: FormattingOptions;
+ /**
+ * Default false. If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then
+ * {@linkcode modify} will insert a new item at that location instead of overwriting its contents.
+ */
+ isArrayInsertion?: boolean;
+ /**
+ * Optional function to define the insertion index given an existing list of properties.
+ */
+ getInsertionIndex?: (properties: string[]) => number;
+}
+/**
+ * Computes the edit operations needed to modify a value in the JSON document.
+ *
+ * @param documentText The input text
+ * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+ * If the path points to an non-existing property or item, it will be created.
+ * @param value The new value for the specified property or item. If the value is undefined,
+ * the property or item will be removed.
+ * @param options Options
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export declare function modify(text: string, path: JSONPath, value: any, options: ModificationOptions): EditResult;
+/**
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+ */
+export declare function applyEdits(text: string, edits: EditResult): string;
diff --git a/tools/ui/node_modules/jsonc-parser/lib/esm/main.js b/tools/ui/node_modules/jsonc-parser/lib/esm/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..18e3cb7168b5cc4401a25bcace1f8af379c408d5
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/esm/main.js
@@ -0,0 +1,178 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+import * as formatter from './impl/format';
+import * as edit from './impl/edit';
+import * as scanner from './impl/scanner';
+import * as parser from './impl/parser';
+/**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+export const createScanner = scanner.createScanner;
+export var ScanError;
+(function (ScanError) {
+ ScanError[ScanError["None"] = 0] = "None";
+ ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+ ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+ ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+ ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+ ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+ ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+export var SyntaxKind;
+(function (SyntaxKind) {
+ SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+ SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+ SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+ SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+ SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+ SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+ SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+ SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+ SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+ SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+ SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+ SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+ SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+ SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+ SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+ SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+ SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+/**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+export const getLocation = parser.getLocation;
+/**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore, always check the errors list to find out if the input was valid.
+ */
+export const parse = parser.parse;
+/**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+export const parseTree = parser.parseTree;
+/**
+ * Finds the node at the given path in a JSON DOM.
+ */
+export const findNodeAtLocation = parser.findNodeAtLocation;
+/**
+ * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+export const findNodeAtOffset = parser.findNodeAtOffset;
+/**
+ * Gets the JSON path of the given JSON DOM node
+ */
+export const getNodePath = parser.getNodePath;
+/**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+export const getNodeValue = parser.getNodeValue;
+/**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+export const visit = parser.visit;
+/**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+export const stripComments = parser.stripComments;
+export var ParseErrorCode;
+(function (ParseErrorCode) {
+ ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+ ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+ ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+ ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+ ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+ ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+ ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+ ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+ ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+ ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+ ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+ ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+ ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+export function printParseErrorCode(code) {
+ switch (code) {
+ case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';
+ case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';
+ case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';
+ case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';
+ case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';
+ case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';
+ case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';
+ case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';
+ case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';
+ case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';
+ case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
+ case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';
+ case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
+ case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';
+ case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
+ case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';
+ }
+ return '';
+}
+/**
+ * Computes the edit operations needed to format a JSON document.
+ *
+ * @param documentText The input text
+ * @param range The range to format or `undefined` to format the full content
+ * @param options The formatting options
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export function format(documentText, range, options) {
+ return formatter.format(documentText, range, options);
+}
+/**
+ * Computes the edit operations needed to modify a value in the JSON document.
+ *
+ * @param documentText The input text
+ * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+ * If the path points to an non-existing property or item, it will be created.
+ * @param value The new value for the specified property or item. If the value is undefined,
+ * the property or item will be removed.
+ * @param options Options
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export function modify(text, path, value, options) {
+ return edit.setProperty(text, path, value, options);
+}
+/**
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+ */
+export function applyEdits(text, edits) {
+ let sortedEdits = edits.slice(0).sort((a, b) => {
+ const diff = a.offset - b.offset;
+ if (diff === 0) {
+ return a.length - b.length;
+ }
+ return diff;
+ });
+ let lastModifiedOffset = text.length;
+ for (let i = sortedEdits.length - 1; i >= 0; i--) {
+ let e = sortedEdits[i];
+ if (e.offset + e.length <= lastModifiedOffset) {
+ text = edit.applyEdit(text, e);
+ }
+ else {
+ throw new Error('Overlapping edit');
+ }
+ lastModifiedOffset = e.offset;
+ }
+ return text;
+}
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/impl/edit.js b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/edit.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9aeefef667d8a725dba6954d5831bdc5ff145f8
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/edit.js
@@ -0,0 +1,201 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports", "./format", "./parser"], factory);
+ }
+})(function (require, exports) {
+ /*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+ 'use strict';
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isWS = exports.applyEdit = exports.setProperty = exports.removeProperty = void 0;
+ const format_1 = require("./format");
+ const parser_1 = require("./parser");
+ function removeProperty(text, path, options) {
+ return setProperty(text, path, void 0, options);
+ }
+ exports.removeProperty = removeProperty;
+ function setProperty(text, originalPath, value, options) {
+ const path = originalPath.slice();
+ const errors = [];
+ const root = (0, parser_1.parseTree)(text, errors);
+ let parent = void 0;
+ let lastSegment = void 0;
+ while (path.length > 0) {
+ lastSegment = path.pop();
+ parent = (0, parser_1.findNodeAtLocation)(root, path);
+ if (parent === void 0 && value !== void 0) {
+ if (typeof lastSegment === 'string') {
+ value = { [lastSegment]: value };
+ }
+ else {
+ value = [value];
+ }
+ }
+ else {
+ break;
+ }
+ }
+ if (!parent) {
+ // empty document
+ if (value === void 0) { // delete
+ throw new Error('Can not delete in empty document');
+ }
+ return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+ }
+ else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
+ const existing = (0, parser_1.findNodeAtLocation)(parent, [lastSegment]);
+ if (existing !== void 0) {
+ if (value === void 0) { // delete
+ if (!existing.parent) {
+ throw new Error('Malformed AST');
+ }
+ const propertyIndex = parent.children.indexOf(existing.parent);
+ let removeBegin;
+ let removeEnd = existing.parent.offset + existing.parent.length;
+ if (propertyIndex > 0) {
+ // remove the comma of the previous node
+ let previous = parent.children[propertyIndex - 1];
+ removeBegin = previous.offset + previous.length;
+ }
+ else {
+ removeBegin = parent.offset + 1;
+ if (parent.children.length > 1) {
+ // remove the comma of the next node
+ let next = parent.children[1];
+ removeEnd = next.offset;
+ }
+ }
+ return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, options);
+ }
+ else {
+ // set value of existing property
+ return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+ }
+ }
+ else {
+ if (value === void 0) { // delete
+ return []; // property does not exist, nothing to do
+ }
+ const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+ const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
+ let edit;
+ if (index > 0) {
+ let previous = parent.children[index - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ else if (parent.children.length === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+ }
+ else {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
+ }
+ return withFormatting(text, edit, options);
+ }
+ }
+ else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
+ const insertIndex = lastSegment;
+ if (insertIndex === -1) {
+ // Insert
+ const newProperty = `${JSON.stringify(value)}`;
+ let edit;
+ if (parent.children.length === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+ }
+ else {
+ const previous = parent.children[parent.children.length - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else if (value === void 0 && parent.children.length >= 0) {
+ // Removal
+ const removalIndex = lastSegment;
+ const toRemove = parent.children[removalIndex];
+ let edit;
+ if (parent.children.length === 1) {
+ // only item
+ edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
+ }
+ else if (parent.children.length - 1 === removalIndex) {
+ // last item
+ let previous = parent.children[removalIndex - 1];
+ let offset = previous.offset + previous.length;
+ let parentEndOffset = parent.offset + parent.length;
+ edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
+ }
+ else {
+ edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else if (value !== void 0) {
+ let edit;
+ const newProperty = `${JSON.stringify(value)}`;
+ if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+ const toModify = parent.children[lastSegment];
+ edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+ }
+ else if (parent.children.length === 0 || lastSegment === 0) {
+ edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
+ }
+ else {
+ const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+ const previous = parent.children[index - 1];
+ edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
+ }
+ return withFormatting(text, edit, options);
+ }
+ else {
+ throw new Error(`Can not ${value === void 0 ? 'remove' : (options.isArrayInsertion ? 'insert' : 'modify')} Array index ${insertIndex} as length is not sufficient`);
+ }
+ }
+ else {
+ throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
+ }
+ }
+ exports.setProperty = setProperty;
+ function withFormatting(text, edit, options) {
+ if (!options.formattingOptions) {
+ return [edit];
+ }
+ // apply the edit
+ let newText = applyEdit(text, edit);
+ // format the new text
+ let begin = edit.offset;
+ let end = edit.offset + edit.content.length;
+ if (edit.length === 0 || edit.content.length === 0) { // insert or remove
+ while (begin > 0 && !(0, format_1.isEOL)(newText, begin - 1)) {
+ begin--;
+ }
+ while (end < newText.length && !(0, format_1.isEOL)(newText, end)) {
+ end++;
+ }
+ }
+ const edits = (0, format_1.format)(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+ // apply the formatting edits and track the begin and end offsets of the changes
+ for (let i = edits.length - 1; i >= 0; i--) {
+ const edit = edits[i];
+ newText = applyEdit(newText, edit);
+ begin = Math.min(begin, edit.offset);
+ end = Math.max(end, edit.offset + edit.length);
+ end += edit.content.length - edit.length;
+ }
+ // create a single edit with all changes
+ const editLength = text.length - (newText.length - end) - begin;
+ return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+ }
+ function applyEdit(text, edit) {
+ return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+ }
+ exports.applyEdit = applyEdit;
+ function isWS(text, offset) {
+ return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
+ }
+ exports.isWS = isWS;
+});
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/impl/format.js b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/format.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b9f2bc54a9ad4ad38a99bbaab4da57f89d40f3d
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/format.js
@@ -0,0 +1,275 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports", "./scanner", "./string-intern"], factory);
+ }
+})(function (require, exports) {
+ /*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+ 'use strict';
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.isEOL = exports.format = void 0;
+ const scanner_1 = require("./scanner");
+ const string_intern_1 = require("./string-intern");
+ function format(documentText, range, options) {
+ let initialIndentLevel;
+ let formatText;
+ let formatTextStart;
+ let rangeStart;
+ let rangeEnd;
+ if (range) {
+ rangeStart = range.offset;
+ rangeEnd = rangeStart + range.length;
+ formatTextStart = rangeStart;
+ while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+ formatTextStart--;
+ }
+ let endOffset = rangeEnd;
+ while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+ endOffset++;
+ }
+ formatText = documentText.substring(formatTextStart, endOffset);
+ initialIndentLevel = computeIndentLevel(formatText, options);
+ }
+ else {
+ formatText = documentText;
+ initialIndentLevel = 0;
+ formatTextStart = 0;
+ rangeStart = 0;
+ rangeEnd = documentText.length;
+ }
+ const eol = getEOL(options, documentText);
+ const eolFastPathSupported = string_intern_1.supportedEols.includes(eol);
+ let numberLineBreaks = 0;
+ let indentLevel = 0;
+ let indentValue;
+ if (options.insertSpaces) {
+ indentValue = string_intern_1.cachedSpaces[options.tabSize || 4] ?? repeat(string_intern_1.cachedSpaces[1], options.tabSize || 4);
+ }
+ else {
+ indentValue = '\t';
+ }
+ const indentType = indentValue === '\t' ? '\t' : ' ';
+ let scanner = (0, scanner_1.createScanner)(formatText, false);
+ let hasError = false;
+ function newLinesAndIndent() {
+ if (numberLineBreaks > 1) {
+ return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+ }
+ const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+ if (!eolFastPathSupported || amountOfSpaces > string_intern_1.cachedBreakLinesWithSpaces[indentType][eol].length) {
+ return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+ }
+ if (amountOfSpaces <= 0) {
+ return eol;
+ }
+ return string_intern_1.cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+ }
+ function scanNext() {
+ let token = scanner.scan();
+ numberLineBreaks = 0;
+ while (token === 15 /* SyntaxKind.Trivia */ || token === 14 /* SyntaxKind.LineBreakTrivia */) {
+ if (token === 14 /* SyntaxKind.LineBreakTrivia */ && options.keepLines) {
+ numberLineBreaks += 1;
+ }
+ else if (token === 14 /* SyntaxKind.LineBreakTrivia */) {
+ numberLineBreaks = 1;
+ }
+ token = scanner.scan();
+ }
+ hasError = token === 16 /* SyntaxKind.Unknown */ || scanner.getTokenError() !== 0 /* ScanError.None */;
+ return token;
+ }
+ const editOperations = [];
+ function addEdit(text, startOffset, endOffset) {
+ if (!hasError && (!range || (startOffset < rangeEnd && endOffset > rangeStart)) && documentText.substring(startOffset, endOffset) !== text) {
+ editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+ }
+ }
+ let firstToken = scanNext();
+ if (options.keepLines && numberLineBreaks > 0) {
+ addEdit(repeat(eol, numberLineBreaks), 0, 0);
+ }
+ if (firstToken !== 17 /* SyntaxKind.EOF */) {
+ let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+ let initialIndent = (indentValue.length * initialIndentLevel < 20) && options.insertSpaces
+ ? string_intern_1.cachedSpaces[indentValue.length * initialIndentLevel]
+ : repeat(indentValue, initialIndentLevel);
+ addEdit(initialIndent, formatTextStart, firstTokenStart);
+ }
+ while (firstToken !== 17 /* SyntaxKind.EOF */) {
+ let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+ let secondToken = scanNext();
+ let replaceContent = '';
+ let needsLineBreak = false;
+ while (numberLineBreaks === 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+ let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+ addEdit(string_intern_1.cachedSpaces[1], firstTokenEnd, commentTokenStart);
+ firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+ needsLineBreak = secondToken === 12 /* SyntaxKind.LineCommentTrivia */;
+ replaceContent = needsLineBreak ? newLinesAndIndent() : '';
+ secondToken = scanNext();
+ }
+ if (secondToken === 2 /* SyntaxKind.CloseBraceToken */) {
+ if (firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
+ indentLevel--;
+ }
+ ;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1 /* SyntaxKind.OpenBraceToken */) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (options.keepLines) {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ }
+ else if (secondToken === 4 /* SyntaxKind.CloseBracketToken */) {
+ if (firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
+ indentLevel--;
+ }
+ ;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3 /* SyntaxKind.OpenBracketToken */) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (options.keepLines) {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ }
+ else {
+ switch (firstToken) {
+ case 3 /* SyntaxKind.OpenBracketToken */:
+ case 1 /* SyntaxKind.OpenBraceToken */:
+ indentLevel++;
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ break;
+ case 5 /* SyntaxKind.CommaToken */:
+ if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ break;
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ replaceContent = newLinesAndIndent();
+ break;
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ if (numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (!needsLineBreak) {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ break;
+ case 6 /* SyntaxKind.ColonToken */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (!needsLineBreak) {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ break;
+ case 10 /* SyntaxKind.StringLiteral */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else if (secondToken === 6 /* SyntaxKind.ColonToken */ && !needsLineBreak) {
+ replaceContent = '';
+ }
+ break;
+ case 7 /* SyntaxKind.NullKeyword */:
+ case 8 /* SyntaxKind.TrueKeyword */:
+ case 9 /* SyntaxKind.FalseKeyword */:
+ case 11 /* SyntaxKind.NumericLiteral */:
+ case 2 /* SyntaxKind.CloseBraceToken */:
+ case 4 /* SyntaxKind.CloseBracketToken */:
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ if ((secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */) && !needsLineBreak) {
+ replaceContent = string_intern_1.cachedSpaces[1];
+ }
+ else if (secondToken !== 5 /* SyntaxKind.CommaToken */ && secondToken !== 17 /* SyntaxKind.EOF */) {
+ hasError = true;
+ }
+ }
+ break;
+ case 16 /* SyntaxKind.Unknown */:
+ hasError = true;
+ break;
+ }
+ if (numberLineBreaks > 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) {
+ replaceContent = newLinesAndIndent();
+ }
+ }
+ if (secondToken === 17 /* SyntaxKind.EOF */) {
+ if (options.keepLines && numberLineBreaks > 0) {
+ replaceContent = newLinesAndIndent();
+ }
+ else {
+ replaceContent = options.insertFinalNewline ? eol : '';
+ }
+ }
+ const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+ addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+ firstToken = secondToken;
+ }
+ return editOperations;
+ }
+ exports.format = format;
+ function repeat(s, count) {
+ let result = '';
+ for (let i = 0; i < count; i++) {
+ result += s;
+ }
+ return result;
+ }
+ function computeIndentLevel(content, options) {
+ let i = 0;
+ let nChars = 0;
+ const tabSize = options.tabSize || 4;
+ while (i < content.length) {
+ let ch = content.charAt(i);
+ if (ch === string_intern_1.cachedSpaces[1]) {
+ nChars++;
+ }
+ else if (ch === '\t') {
+ nChars += tabSize;
+ }
+ else {
+ break;
+ }
+ i++;
+ }
+ return Math.floor(nChars / tabSize);
+ }
+ function getEOL(options, text) {
+ for (let i = 0; i < text.length; i++) {
+ const ch = text.charAt(i);
+ if (ch === '\r') {
+ if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
+ return '\r\n';
+ }
+ return '\r';
+ }
+ else if (ch === '\n') {
+ return '\n';
+ }
+ }
+ return (options && options.eol) || '\n';
+ }
+ function isEOL(text, offset) {
+ return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+ }
+ exports.isEOL = isEOL;
+});
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/impl/parser.js b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/parser.js
new file mode 100644
index 0000000000000000000000000000000000000000..b30bb9364def1b1a14d297a73e5f2e93ae49dac3
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/parser.js
@@ -0,0 +1,682 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports", "./scanner"], factory);
+ }
+})(function (require, exports) {
+ /*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+ 'use strict';
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.getNodeType = exports.stripComments = exports.visit = exports.findNodeAtOffset = exports.contains = exports.getNodeValue = exports.getNodePath = exports.findNodeAtLocation = exports.parseTree = exports.parse = exports.getLocation = void 0;
+ const scanner_1 = require("./scanner");
+ var ParseOptions;
+ (function (ParseOptions) {
+ ParseOptions.DEFAULT = {
+ allowTrailingComma: false
+ };
+ })(ParseOptions || (ParseOptions = {}));
+ /**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+ function getLocation(text, position) {
+ const segments = []; // strings or numbers
+ const earlyReturnException = new Object();
+ let previousNode = undefined;
+ const previousNodeInst = {
+ value: {},
+ offset: 0,
+ length: 0,
+ type: 'object',
+ parent: undefined
+ };
+ let isAtPropertyKey = false;
+ function setPreviousNode(value, offset, length, type) {
+ previousNodeInst.value = value;
+ previousNodeInst.offset = offset;
+ previousNodeInst.length = length;
+ previousNodeInst.type = type;
+ previousNodeInst.colonOffset = undefined;
+ previousNode = previousNodeInst;
+ }
+ try {
+ visit(text, {
+ onObjectBegin: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ isAtPropertyKey = position > offset;
+ segments.push(''); // push a placeholder (will be replaced)
+ },
+ onObjectProperty: (name, offset, length) => {
+ if (position < offset) {
+ throw earlyReturnException;
+ }
+ setPreviousNode(name, offset, length, 'property');
+ segments[segments.length - 1] = name;
+ if (position <= offset + length) {
+ throw earlyReturnException;
+ }
+ },
+ onObjectEnd: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.pop();
+ },
+ onArrayBegin: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.push(0);
+ },
+ onArrayEnd: (offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ previousNode = undefined;
+ segments.pop();
+ },
+ onLiteralValue: (value, offset, length) => {
+ if (position < offset) {
+ throw earlyReturnException;
+ }
+ setPreviousNode(value, offset, length, getNodeType(value));
+ if (position <= offset + length) {
+ throw earlyReturnException;
+ }
+ },
+ onSeparator: (sep, offset, length) => {
+ if (position <= offset) {
+ throw earlyReturnException;
+ }
+ if (sep === ':' && previousNode && previousNode.type === 'property') {
+ previousNode.colonOffset = offset;
+ isAtPropertyKey = false;
+ previousNode = undefined;
+ }
+ else if (sep === ',') {
+ const last = segments[segments.length - 1];
+ if (typeof last === 'number') {
+ segments[segments.length - 1] = last + 1;
+ }
+ else {
+ isAtPropertyKey = true;
+ segments[segments.length - 1] = '';
+ }
+ previousNode = undefined;
+ }
+ }
+ });
+ }
+ catch (e) {
+ if (e !== earlyReturnException) {
+ throw e;
+ }
+ }
+ return {
+ path: segments,
+ previousNode,
+ isAtPropertyKey,
+ matches: (pattern) => {
+ let k = 0;
+ for (let i = 0; k < pattern.length && i < segments.length; i++) {
+ if (pattern[k] === segments[i] || pattern[k] === '*') {
+ k++;
+ }
+ else if (pattern[k] !== '**') {
+ return false;
+ }
+ }
+ return k === pattern.length;
+ }
+ };
+ }
+ exports.getLocation = getLocation;
+ /**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore always check the errors list to find out if the input was valid.
+ */
+ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+ let currentProperty = null;
+ let currentParent = [];
+ const previousParents = [];
+ function onValue(value) {
+ if (Array.isArray(currentParent)) {
+ currentParent.push(value);
+ }
+ else if (currentProperty !== null) {
+ currentParent[currentProperty] = value;
+ }
+ }
+ const visitor = {
+ onObjectBegin: () => {
+ const object = {};
+ onValue(object);
+ previousParents.push(currentParent);
+ currentParent = object;
+ currentProperty = null;
+ },
+ onObjectProperty: (name) => {
+ currentProperty = name;
+ },
+ onObjectEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onArrayBegin: () => {
+ const array = [];
+ onValue(array);
+ previousParents.push(currentParent);
+ currentParent = array;
+ currentProperty = null;
+ },
+ onArrayEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onLiteralValue: onValue,
+ onError: (error, offset, length) => {
+ errors.push({ error, offset, length });
+ }
+ };
+ visit(text, visitor, options);
+ return currentParent[0];
+ }
+ exports.parse = parse;
+ /**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+ function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+ let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
+ function ensurePropertyComplete(endOffset) {
+ if (currentParent.type === 'property') {
+ currentParent.length = endOffset - currentParent.offset;
+ currentParent = currentParent.parent;
+ }
+ }
+ function onValue(valueNode) {
+ currentParent.children.push(valueNode);
+ return valueNode;
+ }
+ const visitor = {
+ onObjectBegin: (offset) => {
+ currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
+ },
+ onObjectProperty: (name, offset, length) => {
+ currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
+ currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
+ },
+ onObjectEnd: (offset, length) => {
+ ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete
+ currentParent.length = offset + length - currentParent.offset;
+ currentParent = currentParent.parent;
+ ensurePropertyComplete(offset + length);
+ },
+ onArrayBegin: (offset, length) => {
+ currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
+ },
+ onArrayEnd: (offset, length) => {
+ currentParent.length = offset + length - currentParent.offset;
+ currentParent = currentParent.parent;
+ ensurePropertyComplete(offset + length);
+ },
+ onLiteralValue: (value, offset, length) => {
+ onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+ ensurePropertyComplete(offset + length);
+ },
+ onSeparator: (sep, offset, length) => {
+ if (currentParent.type === 'property') {
+ if (sep === ':') {
+ currentParent.colonOffset = offset;
+ }
+ else if (sep === ',') {
+ ensurePropertyComplete(offset);
+ }
+ }
+ },
+ onError: (error, offset, length) => {
+ errors.push({ error, offset, length });
+ }
+ };
+ visit(text, visitor, options);
+ const result = currentParent.children[0];
+ if (result) {
+ delete result.parent;
+ }
+ return result;
+ }
+ exports.parseTree = parseTree;
+ /**
+ * Finds the node at the given path in a JSON DOM.
+ */
+ function findNodeAtLocation(root, path) {
+ if (!root) {
+ return undefined;
+ }
+ let node = root;
+ for (let segment of path) {
+ if (typeof segment === 'string') {
+ if (node.type !== 'object' || !Array.isArray(node.children)) {
+ return undefined;
+ }
+ let found = false;
+ for (const propertyNode of node.children) {
+ if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+ node = propertyNode.children[1];
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ return undefined;
+ }
+ }
+ else {
+ const index = segment;
+ if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+ return undefined;
+ }
+ node = node.children[index];
+ }
+ }
+ return node;
+ }
+ exports.findNodeAtLocation = findNodeAtLocation;
+ /**
+ * Gets the JSON path of the given JSON DOM node
+ */
+ function getNodePath(node) {
+ if (!node.parent || !node.parent.children) {
+ return [];
+ }
+ const path = getNodePath(node.parent);
+ if (node.parent.type === 'property') {
+ const key = node.parent.children[0].value;
+ path.push(key);
+ }
+ else if (node.parent.type === 'array') {
+ const index = node.parent.children.indexOf(node);
+ if (index !== -1) {
+ path.push(index);
+ }
+ }
+ return path;
+ }
+ exports.getNodePath = getNodePath;
+ /**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+ function getNodeValue(node) {
+ switch (node.type) {
+ case 'array':
+ return node.children.map(getNodeValue);
+ case 'object':
+ const obj = Object.create(null);
+ for (let prop of node.children) {
+ const valueNode = prop.children[1];
+ if (valueNode) {
+ obj[prop.children[0].value] = getNodeValue(valueNode);
+ }
+ }
+ return obj;
+ case 'null':
+ case 'string':
+ case 'number':
+ case 'boolean':
+ return node.value;
+ default:
+ return undefined;
+ }
+ }
+ exports.getNodeValue = getNodeValue;
+ function contains(node, offset, includeRightBound = false) {
+ return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
+ }
+ exports.contains = contains;
+ /**
+ * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+ function findNodeAtOffset(node, offset, includeRightBound = false) {
+ if (contains(node, offset, includeRightBound)) {
+ const children = node.children;
+ if (Array.isArray(children)) {
+ for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+ const item = findNodeAtOffset(children[i], offset, includeRightBound);
+ if (item) {
+ return item;
+ }
+ }
+ }
+ return node;
+ }
+ return undefined;
+ }
+ exports.findNodeAtOffset = findNodeAtOffset;
+ /**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+ function visit(text, visitor, options = ParseOptions.DEFAULT) {
+ const _scanner = (0, scanner_1.createScanner)(text, false);
+ // Important: Only pass copies of this to visitor functions to prevent accidental modification, and
+ // to not affect visitor functions which stored a reference to a previous JSONPath
+ const _jsonPath = [];
+ // Depth of onXXXBegin() callbacks suppressed. onXXXEnd() decrements this if it isn't 0 already.
+ // Callbacks are only called when this value is 0.
+ let suppressedCallbacks = 0;
+ function toNoArgVisit(visitFunction) {
+ return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ function toOneArgVisit(visitFunction) {
+ return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ function toOneArgVisitWithPath(visitFunction) {
+ return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+ }
+ function toBeginVisit(visitFunction) {
+ return visitFunction ?
+ () => {
+ if (suppressedCallbacks > 0) {
+ suppressedCallbacks++;
+ }
+ else {
+ let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+ if (cbReturn === false) {
+ suppressedCallbacks = 1;
+ }
+ }
+ }
+ : () => true;
+ }
+ function toEndVisit(visitFunction) {
+ return visitFunction ?
+ () => {
+ if (suppressedCallbacks > 0) {
+ suppressedCallbacks--;
+ }
+ if (suppressedCallbacks === 0) {
+ visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+ }
+ }
+ : () => true;
+ }
+ const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+ const disallowComments = options && options.disallowComments;
+ const allowTrailingComma = options && options.allowTrailingComma;
+ function scanNext() {
+ while (true) {
+ const token = _scanner.scan();
+ switch (_scanner.getTokenError()) {
+ case 4 /* ScanError.InvalidUnicode */:
+ handleError(14 /* ParseErrorCode.InvalidUnicode */);
+ break;
+ case 5 /* ScanError.InvalidEscapeCharacter */:
+ handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
+ break;
+ case 3 /* ScanError.UnexpectedEndOfNumber */:
+ handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
+ break;
+ case 1 /* ScanError.UnexpectedEndOfComment */:
+ if (!disallowComments) {
+ handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
+ }
+ break;
+ case 2 /* ScanError.UnexpectedEndOfString */:
+ handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
+ break;
+ case 6 /* ScanError.InvalidCharacter */:
+ handleError(16 /* ParseErrorCode.InvalidCharacter */);
+ break;
+ }
+ switch (token) {
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ if (disallowComments) {
+ handleError(10 /* ParseErrorCode.InvalidCommentToken */);
+ }
+ else {
+ onComment();
+ }
+ break;
+ case 16 /* SyntaxKind.Unknown */:
+ handleError(1 /* ParseErrorCode.InvalidSymbol */);
+ break;
+ case 15 /* SyntaxKind.Trivia */:
+ case 14 /* SyntaxKind.LineBreakTrivia */:
+ break;
+ default:
+ return token;
+ }
+ }
+ }
+ function handleError(error, skipUntilAfter = [], skipUntil = []) {
+ onError(error);
+ if (skipUntilAfter.length + skipUntil.length > 0) {
+ let token = _scanner.getToken();
+ while (token !== 17 /* SyntaxKind.EOF */) {
+ if (skipUntilAfter.indexOf(token) !== -1) {
+ scanNext();
+ break;
+ }
+ else if (skipUntil.indexOf(token) !== -1) {
+ break;
+ }
+ token = scanNext();
+ }
+ }
+ }
+ function parseString(isValue) {
+ const value = _scanner.getTokenValue();
+ if (isValue) {
+ onLiteralValue(value);
+ }
+ else {
+ onObjectProperty(value);
+ // add property name afterwards
+ _jsonPath.push(value);
+ }
+ scanNext();
+ return true;
+ }
+ function parseLiteral() {
+ switch (_scanner.getToken()) {
+ case 11 /* SyntaxKind.NumericLiteral */:
+ const tokenValue = _scanner.getTokenValue();
+ let value = Number(tokenValue);
+ if (isNaN(value)) {
+ handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
+ value = 0;
+ }
+ onLiteralValue(value);
+ break;
+ case 7 /* SyntaxKind.NullKeyword */:
+ onLiteralValue(null);
+ break;
+ case 8 /* SyntaxKind.TrueKeyword */:
+ onLiteralValue(true);
+ break;
+ case 9 /* SyntaxKind.FalseKeyword */:
+ onLiteralValue(false);
+ break;
+ default:
+ return false;
+ }
+ scanNext();
+ return true;
+ }
+ function parseProperty() {
+ if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
+ handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ return false;
+ }
+ parseString(false);
+ if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
+ onSeparator(':');
+ scanNext(); // consume colon
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ }
+ else {
+ handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ _jsonPath.pop(); // remove processed property name
+ return true;
+ }
+ function parseObject() {
+ onObjectBegin();
+ scanNext(); // consume open brace
+ let needsComma = false;
+ while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+ if (!needsComma) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ }
+ onSeparator(',');
+ scanNext(); // consume comma
+ if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
+ break;
+ }
+ }
+ else if (needsComma) {
+ handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+ }
+ if (!parseProperty()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ needsComma = true;
+ }
+ onObjectEnd();
+ if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
+ handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
+ }
+ else {
+ scanNext(); // consume close brace
+ }
+ return true;
+ }
+ function parseArray() {
+ onArrayBegin();
+ scanNext(); // consume open bracket
+ let isFirstElement = true;
+ let needsComma = false;
+ while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+ if (!needsComma) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ }
+ onSeparator(',');
+ scanNext(); // consume comma
+ if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
+ break;
+ }
+ }
+ else if (needsComma) {
+ handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+ }
+ if (isFirstElement) {
+ _jsonPath.push(0);
+ isFirstElement = false;
+ }
+ else {
+ _jsonPath[_jsonPath.length - 1]++;
+ }
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
+ }
+ needsComma = true;
+ }
+ onArrayEnd();
+ if (!isFirstElement) {
+ _jsonPath.pop(); // remove array index
+ }
+ if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
+ handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
+ }
+ else {
+ scanNext(); // consume close bracket
+ }
+ return true;
+ }
+ function parseValue() {
+ switch (_scanner.getToken()) {
+ case 3 /* SyntaxKind.OpenBracketToken */:
+ return parseArray();
+ case 1 /* SyntaxKind.OpenBraceToken */:
+ return parseObject();
+ case 10 /* SyntaxKind.StringLiteral */:
+ return parseString(true);
+ default:
+ return parseLiteral();
+ }
+ }
+ scanNext();
+ if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
+ if (options.allowEmptyContent) {
+ return true;
+ }
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ return false;
+ }
+ if (!parseValue()) {
+ handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+ return false;
+ }
+ if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
+ handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
+ }
+ return true;
+ }
+ exports.visit = visit;
+ /**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+ function stripComments(text, replaceCh) {
+ let _scanner = (0, scanner_1.createScanner)(text), parts = [], kind, offset = 0, pos;
+ do {
+ pos = _scanner.getPosition();
+ kind = _scanner.scan();
+ switch (kind) {
+ case 12 /* SyntaxKind.LineCommentTrivia */:
+ case 13 /* SyntaxKind.BlockCommentTrivia */:
+ case 17 /* SyntaxKind.EOF */:
+ if (offset !== pos) {
+ parts.push(text.substring(offset, pos));
+ }
+ if (replaceCh !== undefined) {
+ parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
+ }
+ offset = _scanner.getPosition();
+ break;
+ }
+ } while (kind !== 17 /* SyntaxKind.EOF */);
+ return parts.join('');
+ }
+ exports.stripComments = stripComments;
+ function getNodeType(value) {
+ switch (typeof value) {
+ case 'boolean': return 'boolean';
+ case 'number': return 'number';
+ case 'string': return 'string';
+ case 'object': {
+ if (!value) {
+ return 'null';
+ }
+ else if (Array.isArray(value)) {
+ return 'array';
+ }
+ return 'object';
+ }
+ default: return 'null';
+ }
+ }
+ exports.getNodeType = getNodeType;
+});
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/impl/scanner.js b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/scanner.js
new file mode 100644
index 0000000000000000000000000000000000000000..ebca65f49cc2507b2ca0f8cd784dfdf414896dd7
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/scanner.js
@@ -0,0 +1,456 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports"], factory);
+ }
+})(function (require, exports) {
+ /*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+ 'use strict';
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.createScanner = void 0;
+ /**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+ function createScanner(text, ignoreTrivia = false) {
+ const len = text.length;
+ let pos = 0, value = '', tokenOffset = 0, token = 16 /* SyntaxKind.Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* ScanError.None */;
+ function scanHexDigits(count, exact) {
+ let digits = 0;
+ let value = 0;
+ while (digits < count || !exact) {
+ let ch = text.charCodeAt(pos);
+ if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
+ value = value * 16 + ch - 48 /* CharacterCodes._0 */;
+ }
+ else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
+ value = value * 16 + ch - 65 /* CharacterCodes.A */ + 10;
+ }
+ else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
+ value = value * 16 + ch - 97 /* CharacterCodes.a */ + 10;
+ }
+ else {
+ break;
+ }
+ pos++;
+ digits++;
+ }
+ if (digits < count) {
+ value = -1;
+ }
+ return value;
+ }
+ function setPosition(newPosition) {
+ pos = newPosition;
+ value = '';
+ tokenOffset = 0;
+ token = 16 /* SyntaxKind.Unknown */;
+ scanError = 0 /* ScanError.None */;
+ }
+ function scanNumber() {
+ let start = pos;
+ if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
+ pos++;
+ }
+ else {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ }
+ if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
+ pos++;
+ if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ }
+ else {
+ scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+ return text.substring(start, pos);
+ }
+ }
+ let end = pos;
+ if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
+ pos++;
+ if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
+ pos++;
+ }
+ if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+ pos++;
+ }
+ end = pos;
+ }
+ else {
+ scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+ }
+ }
+ return text.substring(start, end);
+ }
+ function scanString() {
+ let result = '', start = pos;
+ while (true) {
+ if (pos >= len) {
+ result += text.substring(start, pos);
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ const ch = text.charCodeAt(pos);
+ if (ch === 34 /* CharacterCodes.doubleQuote */) {
+ result += text.substring(start, pos);
+ pos++;
+ break;
+ }
+ if (ch === 92 /* CharacterCodes.backslash */) {
+ result += text.substring(start, pos);
+ pos++;
+ if (pos >= len) {
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ const ch2 = text.charCodeAt(pos++);
+ switch (ch2) {
+ case 34 /* CharacterCodes.doubleQuote */:
+ result += '\"';
+ break;
+ case 92 /* CharacterCodes.backslash */:
+ result += '\\';
+ break;
+ case 47 /* CharacterCodes.slash */:
+ result += '/';
+ break;
+ case 98 /* CharacterCodes.b */:
+ result += '\b';
+ break;
+ case 102 /* CharacterCodes.f */:
+ result += '\f';
+ break;
+ case 110 /* CharacterCodes.n */:
+ result += '\n';
+ break;
+ case 114 /* CharacterCodes.r */:
+ result += '\r';
+ break;
+ case 116 /* CharacterCodes.t */:
+ result += '\t';
+ break;
+ case 117 /* CharacterCodes.u */:
+ const ch3 = scanHexDigits(4, true);
+ if (ch3 >= 0) {
+ result += String.fromCharCode(ch3);
+ }
+ else {
+ scanError = 4 /* ScanError.InvalidUnicode */;
+ }
+ break;
+ default:
+ scanError = 5 /* ScanError.InvalidEscapeCharacter */;
+ }
+ start = pos;
+ continue;
+ }
+ if (ch >= 0 && ch <= 0x1f) {
+ if (isLineBreak(ch)) {
+ result += text.substring(start, pos);
+ scanError = 2 /* ScanError.UnexpectedEndOfString */;
+ break;
+ }
+ else {
+ scanError = 6 /* ScanError.InvalidCharacter */;
+ // mark as error but continue with string
+ }
+ }
+ pos++;
+ }
+ return result;
+ }
+ function scanNext() {
+ value = '';
+ scanError = 0 /* ScanError.None */;
+ tokenOffset = pos;
+ lineStartOffset = lineNumber;
+ prevTokenLineStartOffset = tokenLineStartOffset;
+ if (pos >= len) {
+ // at the end
+ tokenOffset = len;
+ return token = 17 /* SyntaxKind.EOF */;
+ }
+ let code = text.charCodeAt(pos);
+ // trivia: whitespace
+ if (isWhiteSpace(code)) {
+ do {
+ pos++;
+ value += String.fromCharCode(code);
+ code = text.charCodeAt(pos);
+ } while (isWhiteSpace(code));
+ return token = 15 /* SyntaxKind.Trivia */;
+ }
+ // trivia: newlines
+ if (isLineBreak(code)) {
+ pos++;
+ value += String.fromCharCode(code);
+ if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
+ pos++;
+ value += '\n';
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ return token = 14 /* SyntaxKind.LineBreakTrivia */;
+ }
+ switch (code) {
+ // tokens: []{}:,
+ case 123 /* CharacterCodes.openBrace */:
+ pos++;
+ return token = 1 /* SyntaxKind.OpenBraceToken */;
+ case 125 /* CharacterCodes.closeBrace */:
+ pos++;
+ return token = 2 /* SyntaxKind.CloseBraceToken */;
+ case 91 /* CharacterCodes.openBracket */:
+ pos++;
+ return token = 3 /* SyntaxKind.OpenBracketToken */;
+ case 93 /* CharacterCodes.closeBracket */:
+ pos++;
+ return token = 4 /* SyntaxKind.CloseBracketToken */;
+ case 58 /* CharacterCodes.colon */:
+ pos++;
+ return token = 6 /* SyntaxKind.ColonToken */;
+ case 44 /* CharacterCodes.comma */:
+ pos++;
+ return token = 5 /* SyntaxKind.CommaToken */;
+ // strings
+ case 34 /* CharacterCodes.doubleQuote */:
+ pos++;
+ value = scanString();
+ return token = 10 /* SyntaxKind.StringLiteral */;
+ // comments
+ case 47 /* CharacterCodes.slash */:
+ const start = pos - 1;
+ // Single-line comment
+ if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+ pos += 2;
+ while (pos < len) {
+ if (isLineBreak(text.charCodeAt(pos))) {
+ break;
+ }
+ pos++;
+ }
+ value = text.substring(start, pos);
+ return token = 12 /* SyntaxKind.LineCommentTrivia */;
+ }
+ // Multi-line comment
+ if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
+ pos += 2;
+ const safeLength = len - 1; // For lookahead.
+ let commentClosed = false;
+ while (pos < safeLength) {
+ const ch = text.charCodeAt(pos);
+ if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+ pos += 2;
+ commentClosed = true;
+ break;
+ }
+ pos++;
+ if (isLineBreak(ch)) {
+ if (ch === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
+ pos++;
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ }
+ }
+ if (!commentClosed) {
+ pos++;
+ scanError = 1 /* ScanError.UnexpectedEndOfComment */;
+ }
+ value = text.substring(start, pos);
+ return token = 13 /* SyntaxKind.BlockCommentTrivia */;
+ }
+ // just a single slash
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16 /* SyntaxKind.Unknown */;
+ // numbers
+ case 45 /* CharacterCodes.minus */:
+ value += String.fromCharCode(code);
+ pos++;
+ if (pos === len || !isDigit(text.charCodeAt(pos))) {
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ // found a minus, followed by a number so
+ // we fall through to proceed with scanning
+ // numbers
+ case 48 /* CharacterCodes._0 */:
+ case 49 /* CharacterCodes._1 */:
+ case 50 /* CharacterCodes._2 */:
+ case 51 /* CharacterCodes._3 */:
+ case 52 /* CharacterCodes._4 */:
+ case 53 /* CharacterCodes._5 */:
+ case 54 /* CharacterCodes._6 */:
+ case 55 /* CharacterCodes._7 */:
+ case 56 /* CharacterCodes._8 */:
+ case 57 /* CharacterCodes._9 */:
+ value += scanNumber();
+ return token = 11 /* SyntaxKind.NumericLiteral */;
+ // literals and unknown symbols
+ default:
+ // is a literal? Read the full word.
+ while (pos < len && isUnknownContentCharacter(code)) {
+ pos++;
+ code = text.charCodeAt(pos);
+ }
+ if (tokenOffset !== pos) {
+ value = text.substring(tokenOffset, pos);
+ // keywords: true, false, null
+ switch (value) {
+ case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
+ case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
+ case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
+ }
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ // some
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16 /* SyntaxKind.Unknown */;
+ }
+ }
+ function isUnknownContentCharacter(code) {
+ if (isWhiteSpace(code) || isLineBreak(code)) {
+ return false;
+ }
+ switch (code) {
+ case 125 /* CharacterCodes.closeBrace */:
+ case 93 /* CharacterCodes.closeBracket */:
+ case 123 /* CharacterCodes.openBrace */:
+ case 91 /* CharacterCodes.openBracket */:
+ case 34 /* CharacterCodes.doubleQuote */:
+ case 58 /* CharacterCodes.colon */:
+ case 44 /* CharacterCodes.comma */:
+ case 47 /* CharacterCodes.slash */:
+ return false;
+ }
+ return true;
+ }
+ function scanNextNonTrivia() {
+ let result;
+ do {
+ result = scanNext();
+ } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
+ return result;
+ }
+ return {
+ setPosition: setPosition,
+ getPosition: () => pos,
+ scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+ getToken: () => token,
+ getTokenValue: () => value,
+ getTokenOffset: () => tokenOffset,
+ getTokenLength: () => pos - tokenOffset,
+ getTokenStartLine: () => lineStartOffset,
+ getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+ getTokenError: () => scanError,
+ };
+ }
+ exports.createScanner = createScanner;
+ function isWhiteSpace(ch) {
+ return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */;
+ }
+ function isLineBreak(ch) {
+ return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */;
+ }
+ function isDigit(ch) {
+ return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
+ }
+ var CharacterCodes;
+ (function (CharacterCodes) {
+ CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+ CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+ CharacterCodes[CharacterCodes["space"] = 32] = "space";
+ CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+ CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+ CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+ CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+ CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+ CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+ CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+ CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+ CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+ CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+ CharacterCodes[CharacterCodes["a"] = 97] = "a";
+ CharacterCodes[CharacterCodes["b"] = 98] = "b";
+ CharacterCodes[CharacterCodes["c"] = 99] = "c";
+ CharacterCodes[CharacterCodes["d"] = 100] = "d";
+ CharacterCodes[CharacterCodes["e"] = 101] = "e";
+ CharacterCodes[CharacterCodes["f"] = 102] = "f";
+ CharacterCodes[CharacterCodes["g"] = 103] = "g";
+ CharacterCodes[CharacterCodes["h"] = 104] = "h";
+ CharacterCodes[CharacterCodes["i"] = 105] = "i";
+ CharacterCodes[CharacterCodes["j"] = 106] = "j";
+ CharacterCodes[CharacterCodes["k"] = 107] = "k";
+ CharacterCodes[CharacterCodes["l"] = 108] = "l";
+ CharacterCodes[CharacterCodes["m"] = 109] = "m";
+ CharacterCodes[CharacterCodes["n"] = 110] = "n";
+ CharacterCodes[CharacterCodes["o"] = 111] = "o";
+ CharacterCodes[CharacterCodes["p"] = 112] = "p";
+ CharacterCodes[CharacterCodes["q"] = 113] = "q";
+ CharacterCodes[CharacterCodes["r"] = 114] = "r";
+ CharacterCodes[CharacterCodes["s"] = 115] = "s";
+ CharacterCodes[CharacterCodes["t"] = 116] = "t";
+ CharacterCodes[CharacterCodes["u"] = 117] = "u";
+ CharacterCodes[CharacterCodes["v"] = 118] = "v";
+ CharacterCodes[CharacterCodes["w"] = 119] = "w";
+ CharacterCodes[CharacterCodes["x"] = 120] = "x";
+ CharacterCodes[CharacterCodes["y"] = 121] = "y";
+ CharacterCodes[CharacterCodes["z"] = 122] = "z";
+ CharacterCodes[CharacterCodes["A"] = 65] = "A";
+ CharacterCodes[CharacterCodes["B"] = 66] = "B";
+ CharacterCodes[CharacterCodes["C"] = 67] = "C";
+ CharacterCodes[CharacterCodes["D"] = 68] = "D";
+ CharacterCodes[CharacterCodes["E"] = 69] = "E";
+ CharacterCodes[CharacterCodes["F"] = 70] = "F";
+ CharacterCodes[CharacterCodes["G"] = 71] = "G";
+ CharacterCodes[CharacterCodes["H"] = 72] = "H";
+ CharacterCodes[CharacterCodes["I"] = 73] = "I";
+ CharacterCodes[CharacterCodes["J"] = 74] = "J";
+ CharacterCodes[CharacterCodes["K"] = 75] = "K";
+ CharacterCodes[CharacterCodes["L"] = 76] = "L";
+ CharacterCodes[CharacterCodes["M"] = 77] = "M";
+ CharacterCodes[CharacterCodes["N"] = 78] = "N";
+ CharacterCodes[CharacterCodes["O"] = 79] = "O";
+ CharacterCodes[CharacterCodes["P"] = 80] = "P";
+ CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+ CharacterCodes[CharacterCodes["R"] = 82] = "R";
+ CharacterCodes[CharacterCodes["S"] = 83] = "S";
+ CharacterCodes[CharacterCodes["T"] = 84] = "T";
+ CharacterCodes[CharacterCodes["U"] = 85] = "U";
+ CharacterCodes[CharacterCodes["V"] = 86] = "V";
+ CharacterCodes[CharacterCodes["W"] = 87] = "W";
+ CharacterCodes[CharacterCodes["X"] = 88] = "X";
+ CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+ CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+ CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+ CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+ CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+ CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+ CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+ CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+ CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+ CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+ CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+ CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+ CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+ CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+ CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+ CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+ CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
+ })(CharacterCodes || (CharacterCodes = {}));
+});
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/impl/string-intern.js b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/string-intern.js
new file mode 100644
index 0000000000000000000000000000000000000000..177f2d72734a7fdad28df179e9d00e32bf17657c
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/impl/string-intern.js
@@ -0,0 +1,42 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports"], factory);
+ }
+})(function (require, exports) {
+ "use strict";
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.supportedEols = exports.cachedBreakLinesWithSpaces = exports.cachedSpaces = void 0;
+ exports.cachedSpaces = new Array(20).fill(0).map((_, index) => {
+ return ' '.repeat(index);
+ });
+ const maxCachedValues = 200;
+ exports.cachedBreakLinesWithSpaces = {
+ ' ': {
+ '\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\n' + ' '.repeat(index);
+ }),
+ '\r': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r' + ' '.repeat(index);
+ }),
+ '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r\n' + ' '.repeat(index);
+ }),
+ },
+ '\t': {
+ '\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\n' + '\t'.repeat(index);
+ }),
+ '\r': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r' + '\t'.repeat(index);
+ }),
+ '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => {
+ return '\r\n' + '\t'.repeat(index);
+ }),
+ }
+ };
+ exports.supportedEols = ['\n', '\r', '\r\n'];
+});
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/main.d.ts b/tools/ui/node_modules/jsonc-parser/lib/umd/main.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..66c1691fde24ede6a90f482123a712961f6499e4
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/main.d.ts
@@ -0,0 +1,351 @@
+/**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+export declare const createScanner: (text: string, ignoreTrivia?: boolean) => JSONScanner;
+export declare const enum ScanError {
+ None = 0,
+ UnexpectedEndOfComment = 1,
+ UnexpectedEndOfString = 2,
+ UnexpectedEndOfNumber = 3,
+ InvalidUnicode = 4,
+ InvalidEscapeCharacter = 5,
+ InvalidCharacter = 6
+}
+export declare const enum SyntaxKind {
+ OpenBraceToken = 1,
+ CloseBraceToken = 2,
+ OpenBracketToken = 3,
+ CloseBracketToken = 4,
+ CommaToken = 5,
+ ColonToken = 6,
+ NullKeyword = 7,
+ TrueKeyword = 8,
+ FalseKeyword = 9,
+ StringLiteral = 10,
+ NumericLiteral = 11,
+ LineCommentTrivia = 12,
+ BlockCommentTrivia = 13,
+ LineBreakTrivia = 14,
+ Trivia = 15,
+ Unknown = 16,
+ EOF = 17
+}
+/**
+ * The scanner object, representing a JSON scanner at a position in the input string.
+ */
+export interface JSONScanner {
+ /**
+ * Sets the scan position to a new offset. A call to 'scan' is needed to get the first token.
+ */
+ setPosition(pos: number): void;
+ /**
+ * Read the next token. Returns the token code.
+ */
+ scan(): SyntaxKind;
+ /**
+ * Returns the zero-based current scan position, which is after the last read token.
+ */
+ getPosition(): number;
+ /**
+ * Returns the last read token.
+ */
+ getToken(): SyntaxKind;
+ /**
+ * Returns the last read token value. The value for strings is the decoded string content. For numbers it's of type number, for boolean it's true or false.
+ */
+ getTokenValue(): string;
+ /**
+ * The zero-based start offset of the last read token.
+ */
+ getTokenOffset(): number;
+ /**
+ * The length of the last read token.
+ */
+ getTokenLength(): number;
+ /**
+ * The zero-based start line number of the last read token.
+ */
+ getTokenStartLine(): number;
+ /**
+ * The zero-based start character (column) of the last read token.
+ */
+ getTokenStartCharacter(): number;
+ /**
+ * An error code of the last scan.
+ */
+ getTokenError(): ScanError;
+}
+/**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+export declare const getLocation: (text: string, position: number) => Location;
+/**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore, always check the errors list to find out if the input was valid.
+ */
+export declare const parse: (text: string, errors?: ParseError[], options?: ParseOptions) => any;
+/**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+export declare const parseTree: (text: string, errors?: ParseError[], options?: ParseOptions) => Node | undefined;
+/**
+ * Finds the node at the given path in a JSON DOM.
+ */
+export declare const findNodeAtLocation: (root: Node, path: JSONPath) => Node | undefined;
+/**
+ * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+export declare const findNodeAtOffset: (root: Node, offset: number, includeRightBound?: boolean) => Node | undefined;
+/**
+ * Gets the JSON path of the given JSON DOM node
+ */
+export declare const getNodePath: (node: Node) => JSONPath;
+/**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+export declare const getNodeValue: (node: Node) => any;
+/**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+export declare const visit: (text: string, visitor: JSONVisitor, options?: ParseOptions) => any;
+/**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+export declare const stripComments: (text: string, replaceCh?: string) => string;
+export interface ParseError {
+ error: ParseErrorCode;
+ offset: number;
+ length: number;
+}
+export declare const enum ParseErrorCode {
+ InvalidSymbol = 1,
+ InvalidNumberFormat = 2,
+ PropertyNameExpected = 3,
+ ValueExpected = 4,
+ ColonExpected = 5,
+ CommaExpected = 6,
+ CloseBraceExpected = 7,
+ CloseBracketExpected = 8,
+ EndOfFileExpected = 9,
+ InvalidCommentToken = 10,
+ UnexpectedEndOfComment = 11,
+ UnexpectedEndOfString = 12,
+ UnexpectedEndOfNumber = 13,
+ InvalidUnicode = 14,
+ InvalidEscapeCharacter = 15,
+ InvalidCharacter = 16
+}
+export declare function printParseErrorCode(code: ParseErrorCode): "InvalidSymbol" | "InvalidNumberFormat" | "PropertyNameExpected" | "ValueExpected" | "ColonExpected" | "CommaExpected" | "CloseBraceExpected" | "CloseBracketExpected" | "EndOfFileExpected" | "InvalidCommentToken" | "UnexpectedEndOfComment" | "UnexpectedEndOfString" | "UnexpectedEndOfNumber" | "InvalidUnicode" | "InvalidEscapeCharacter" | "InvalidCharacter" | "";
+export type NodeType = 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
+export interface Node {
+ readonly type: NodeType;
+ readonly value?: any;
+ readonly offset: number;
+ readonly length: number;
+ readonly colonOffset?: number;
+ readonly parent?: Node;
+ readonly children?: Node[];
+}
+/**
+ * A {@linkcode JSONPath} segment. Either a string representing an object property name
+ * or a number (starting at 0) for array indices.
+ */
+export type Segment = string | number;
+export type JSONPath = Segment[];
+export interface Location {
+ /**
+ * The previous property key or literal value (string, number, boolean or null) or undefined.
+ */
+ previousNode?: Node;
+ /**
+ * The path describing the location in the JSON document. The path consists of a sequence of strings
+ * representing an object property or numbers for array indices.
+ */
+ path: JSONPath;
+ /**
+ * Matches the locations path against a pattern consisting of strings (for properties) and numbers (for array indices).
+ * '*' will match a single segment of any property name or index.
+ * '**' will match a sequence of segments of any property name or index, or no segment.
+ */
+ matches: (patterns: JSONPath) => boolean;
+ /**
+ * If set, the location's offset is at a property key.
+ */
+ isAtPropertyKey: boolean;
+}
+export interface ParseOptions {
+ disallowComments?: boolean;
+ allowTrailingComma?: boolean;
+ allowEmptyContent?: boolean;
+}
+/**
+ * Visitor called by {@linkcode visit} when parsing JSON.
+ *
+ * The visitor functions have the following common parameters:
+ * - `offset`: Global offset within the JSON document, starting at 0
+ * - `startLine`: Line number, starting at 0
+ * - `startCharacter`: Start character (column) within the current line, starting at 0
+ *
+ * Additionally some functions have a `pathSupplier` parameter which can be used to obtain the
+ * current `JSONPath` within the document.
+ */
+export interface JSONVisitor {
+ /**
+ * Invoked when an open brace is encountered and an object is started. The offset and length represent the location of the open brace.
+ * When `false` is returned, the object properties will not be visited.
+ */
+ onObjectBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => boolean | void;
+ /**
+ * Invoked when a property is encountered. The offset and length represent the location of the property name.
+ * The `JSONPath` created by the `pathSupplier` refers to the enclosing JSON object, it does not include the
+ * property name yet.
+ */
+ onObjectProperty?: (property: string, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a closing brace is encountered and an object is completed. The offset and length represent the location of the closing brace.
+ */
+ onObjectEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when an open bracket is encountered. The offset and length represent the location of the open bracket.
+ * When `false` is returned, the array items will not be visited.
+ */
+ onArrayBegin?: (offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => boolean | void;
+ /**
+ * Invoked when a closing bracket is encountered. The offset and length represent the location of the closing bracket.
+ */
+ onArrayEnd?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked when a literal value is encountered. The offset and length represent the location of the literal value.
+ */
+ onLiteralValue?: (value: any, offset: number, length: number, startLine: number, startCharacter: number, pathSupplier: () => JSONPath) => void;
+ /**
+ * Invoked when a comma or colon separator is encountered. The offset and length represent the location of the separator.
+ */
+ onSeparator?: (character: string, offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * When comments are allowed, invoked when a line or block comment is encountered. The offset and length represent the location of the comment.
+ */
+ onComment?: (offset: number, length: number, startLine: number, startCharacter: number) => void;
+ /**
+ * Invoked on an error.
+ */
+ onError?: (error: ParseErrorCode, offset: number, length: number, startLine: number, startCharacter: number) => void;
+}
+/**
+ * An edit result describes a textual edit operation. It is the result of a {@linkcode format} and {@linkcode modify} operation.
+ * It consist of one or more edits describing insertions, replacements or removals of text segments.
+ * * The offsets of the edits refer to the original state of the document.
+ * * No two edits change or remove the same range of text in the original document.
+ * * Multiple edits can have the same offset if they are multiple inserts, or an insert followed by a remove or replace.
+ * * The order in the array defines which edit is applied first.
+ * To apply an edit result use {@linkcode applyEdits}.
+ * In general multiple EditResults must not be concatenated because they might impact each other, producing incorrect or malformed JSON data.
+ */
+export type EditResult = Edit[];
+/**
+ * Represents a text modification
+ */
+export interface Edit {
+ /**
+ * The start offset of the modification.
+ */
+ offset: number;
+ /**
+ * The length of the modification. Must not be negative. Empty length represents an *insert*.
+ */
+ length: number;
+ /**
+ * The new content. Empty content represents a *remove*.
+ */
+ content: string;
+}
+/**
+ * A text range in the document
+*/
+export interface Range {
+ /**
+ * The start offset of the range.
+ */
+ offset: number;
+ /**
+ * The length of the range. Must not be negative.
+ */
+ length: number;
+}
+/**
+ * Options used by {@linkcode format} when computing the formatting edit operations
+ */
+export interface FormattingOptions {
+ /**
+ * If indentation is based on spaces (`insertSpaces` = true), the number of spaces that make an indent.
+ */
+ tabSize?: number;
+ /**
+ * Is indentation based on spaces?
+ */
+ insertSpaces?: boolean;
+ /**
+ * The default 'end of line' character. If not set, '\n' is used as default.
+ */
+ eol?: string;
+ /**
+ * If set, will add a new line at the end of the document.
+ */
+ insertFinalNewline?: boolean;
+ /**
+ * If true, will keep line positions as is in the formatting
+ */
+ keepLines?: boolean;
+}
+/**
+ * Computes the edit operations needed to format a JSON document.
+ *
+ * @param documentText The input text
+ * @param range The range to format or `undefined` to format the full content
+ * @param options The formatting options
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export declare function format(documentText: string, range: Range | undefined, options: FormattingOptions): EditResult;
+/**
+ * Options used by {@linkcode modify} when computing the modification edit operations
+ */
+export interface ModificationOptions {
+ /**
+ * Formatting options. If undefined, the newly inserted code will be inserted unformatted.
+ */
+ formattingOptions?: FormattingOptions;
+ /**
+ * Default false. If `JSONPath` refers to an index of an array and `isArrayInsertion` is `true`, then
+ * {@linkcode modify} will insert a new item at that location instead of overwriting its contents.
+ */
+ isArrayInsertion?: boolean;
+ /**
+ * Optional function to define the insertion index given an existing list of properties.
+ */
+ getInsertionIndex?: (properties: string[]) => number;
+}
+/**
+ * Computes the edit operations needed to modify a value in the JSON document.
+ *
+ * @param documentText The input text
+ * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+ * If the path points to an non-existing property or item, it will be created.
+ * @param value The new value for the specified property or item. If the value is undefined,
+ * the property or item will be removed.
+ * @param options Options
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+export declare function modify(text: string, path: JSONPath, value: any, options: ModificationOptions): EditResult;
+/**
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+ */
+export declare function applyEdits(text: string, edits: EditResult): string;
diff --git a/tools/ui/node_modules/jsonc-parser/lib/umd/main.js b/tools/ui/node_modules/jsonc-parser/lib/umd/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ed744665430578caebcb12053150fbf4d7e76da
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/lib/umd/main.js
@@ -0,0 +1,194 @@
+(function (factory) {
+ if (typeof module === "object" && typeof module.exports === "object") {
+ var v = factory(require, exports);
+ if (v !== undefined) module.exports = v;
+ }
+ else if (typeof define === "function" && define.amd) {
+ define(["require", "exports", "./impl/format", "./impl/edit", "./impl/scanner", "./impl/parser"], factory);
+ }
+})(function (require, exports) {
+ /*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+ 'use strict';
+ Object.defineProperty(exports, "__esModule", { value: true });
+ exports.applyEdits = exports.modify = exports.format = exports.printParseErrorCode = exports.ParseErrorCode = exports.stripComments = exports.visit = exports.getNodeValue = exports.getNodePath = exports.findNodeAtOffset = exports.findNodeAtLocation = exports.parseTree = exports.parse = exports.getLocation = exports.SyntaxKind = exports.ScanError = exports.createScanner = void 0;
+ const formatter = require("./impl/format");
+ const edit = require("./impl/edit");
+ const scanner = require("./impl/scanner");
+ const parser = require("./impl/parser");
+ /**
+ * Creates a JSON scanner on the given text.
+ * If ignoreTrivia is set, whitespaces or comments are ignored.
+ */
+ exports.createScanner = scanner.createScanner;
+ var ScanError;
+ (function (ScanError) {
+ ScanError[ScanError["None"] = 0] = "None";
+ ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+ ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+ ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+ ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+ ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+ ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
+ })(ScanError || (exports.ScanError = ScanError = {}));
+ var SyntaxKind;
+ (function (SyntaxKind) {
+ SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+ SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+ SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+ SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+ SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+ SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+ SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+ SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+ SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+ SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+ SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+ SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+ SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+ SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+ SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+ SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+ SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
+ })(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {}));
+ /**
+ * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
+ */
+ exports.getLocation = parser.getLocation;
+ /**
+ * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ * Therefore, always check the errors list to find out if the input was valid.
+ */
+ exports.parse = parser.parse;
+ /**
+ * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ */
+ exports.parseTree = parser.parseTree;
+ /**
+ * Finds the node at the given path in a JSON DOM.
+ */
+ exports.findNodeAtLocation = parser.findNodeAtLocation;
+ /**
+ * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
+ */
+ exports.findNodeAtOffset = parser.findNodeAtOffset;
+ /**
+ * Gets the JSON path of the given JSON DOM node
+ */
+ exports.getNodePath = parser.getNodePath;
+ /**
+ * Evaluates the JavaScript object of the given JSON DOM node
+ */
+ exports.getNodeValue = parser.getNodeValue;
+ /**
+ * Parses the given text and invokes the visitor functions for each object, array and literal reached.
+ */
+ exports.visit = parser.visit;
+ /**
+ * Takes JSON with JavaScript-style comments and remove
+ * them. Optionally replaces every none-newline character
+ * of comments with a replaceCharacter
+ */
+ exports.stripComments = parser.stripComments;
+ var ParseErrorCode;
+ (function (ParseErrorCode) {
+ ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+ ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+ ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+ ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+ ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+ ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+ ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+ ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+ ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+ ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+ ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+ ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+ ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+ ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
+ })(ParseErrorCode || (exports.ParseErrorCode = ParseErrorCode = {}));
+ function printParseErrorCode(code) {
+ switch (code) {
+ case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol';
+ case 2 /* ParseErrorCode.InvalidNumberFormat */: return 'InvalidNumberFormat';
+ case 3 /* ParseErrorCode.PropertyNameExpected */: return 'PropertyNameExpected';
+ case 4 /* ParseErrorCode.ValueExpected */: return 'ValueExpected';
+ case 5 /* ParseErrorCode.ColonExpected */: return 'ColonExpected';
+ case 6 /* ParseErrorCode.CommaExpected */: return 'CommaExpected';
+ case 7 /* ParseErrorCode.CloseBraceExpected */: return 'CloseBraceExpected';
+ case 8 /* ParseErrorCode.CloseBracketExpected */: return 'CloseBracketExpected';
+ case 9 /* ParseErrorCode.EndOfFileExpected */: return 'EndOfFileExpected';
+ case 10 /* ParseErrorCode.InvalidCommentToken */: return 'InvalidCommentToken';
+ case 11 /* ParseErrorCode.UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';
+ case 12 /* ParseErrorCode.UnexpectedEndOfString */: return 'UnexpectedEndOfString';
+ case 13 /* ParseErrorCode.UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';
+ case 14 /* ParseErrorCode.InvalidUnicode */: return 'InvalidUnicode';
+ case 15 /* ParseErrorCode.InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';
+ case 16 /* ParseErrorCode.InvalidCharacter */: return 'InvalidCharacter';
+ }
+ return '';
+ }
+ exports.printParseErrorCode = printParseErrorCode;
+ /**
+ * Computes the edit operations needed to format a JSON document.
+ *
+ * @param documentText The input text
+ * @param range The range to format or `undefined` to format the full content
+ * @param options The formatting options
+ * @returns The edit operations describing the formatting changes to the original document following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+ function format(documentText, range, options) {
+ return formatter.format(documentText, range, options);
+ }
+ exports.format = format;
+ /**
+ * Computes the edit operations needed to modify a value in the JSON document.
+ *
+ * @param documentText The input text
+ * @param path The path of the value to change. The path represents either to the document root, a property or an array item.
+ * If the path points to an non-existing property or item, it will be created.
+ * @param value The new value for the specified property or item. If the value is undefined,
+ * the property or item will be removed.
+ * @param options Options
+ * @returns The edit operations describing the changes to the original document, following the format described in {@linkcode EditResult}.
+ * To apply the edit operations to the input, use {@linkcode applyEdits}.
+ */
+ function modify(text, path, value, options) {
+ return edit.setProperty(text, path, value, options);
+ }
+ exports.modify = modify;
+ /**
+ * Applies edits to an input string.
+ * @param text The input text
+ * @param edits Edit operations following the format described in {@linkcode EditResult}.
+ * @returns The text with the applied edits.
+ * @throws An error if the edit operations are not well-formed as described in {@linkcode EditResult}.
+ */
+ function applyEdits(text, edits) {
+ let sortedEdits = edits.slice(0).sort((a, b) => {
+ const diff = a.offset - b.offset;
+ if (diff === 0) {
+ return a.length - b.length;
+ }
+ return diff;
+ });
+ let lastModifiedOffset = text.length;
+ for (let i = sortedEdits.length - 1; i >= 0; i--) {
+ let e = sortedEdits[i];
+ if (e.offset + e.length <= lastModifiedOffset) {
+ text = edit.applyEdit(text, e);
+ }
+ else {
+ throw new Error('Overlapping edit');
+ }
+ lastModifiedOffset = e.offset;
+ }
+ return text;
+ }
+ exports.applyEdits = applyEdits;
+});
diff --git a/tools/ui/node_modules/jsonc-parser/package.json b/tools/ui/node_modules/jsonc-parser/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..6536a20b66c000f3991c470e6f24539e3a822d9e
--- /dev/null
+++ b/tools/ui/node_modules/jsonc-parser/package.json
@@ -0,0 +1,37 @@
+{
+ "name": "jsonc-parser",
+ "version": "3.3.1",
+ "description": "Scanner and parser for JSON with comments.",
+ "main": "./lib/umd/main.js",
+ "typings": "./lib/umd/main.d.ts",
+ "module": "./lib/esm/main.js",
+ "author": "Microsoft Corporation",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/microsoft/node-jsonc-parser"
+ },
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/microsoft/node-jsonc-parser/issues"
+ },
+ "devDependencies": {
+ "@types/mocha": "^10.0.7",
+ "@types/node": "^18.x",
+ "@typescript-eslint/eslint-plugin": "^7.13.1",
+ "@typescript-eslint/parser": "^7.13.1",
+ "eslint": "^8.57.0",
+ "mocha": "^10.4.0",
+ "rimraf": "^5.0.7",
+ "typescript": "^5.4.2"
+ },
+ "scripts": {
+ "prepack": "npm run clean && npm run compile-esm && npm run test && npm run remove-sourcemap-refs",
+ "compile": "tsc -p ./src && npm run lint",
+ "compile-esm": "tsc -p ./src/tsconfig.esm.json",
+ "remove-sourcemap-refs": "node ./build/remove-sourcemap-refs.js",
+ "clean": "rimraf lib",
+ "watch": "tsc -w -p ./src",
+ "test": "npm run compile && mocha ./lib/umd/test",
+ "lint": "eslint src/**/*.ts"
+ }
+}
diff --git a/tools/ui/node_modules/jsonfile/LICENSE b/tools/ui/node_modules/jsonfile/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..cb7e807b9bdb33c128dba99d56eeedd7b8cba452
--- /dev/null
+++ b/tools/ui/node_modules/jsonfile/LICENSE
@@ -0,0 +1,15 @@
+(The MIT License)
+
+Copyright (c) 2012-2015, JP Richardson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
+(the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
+ merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/jsonfile/README.md b/tools/ui/node_modules/jsonfile/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..215dc0918a2a18e915c1861ed7c1d53e0bf73763
--- /dev/null
+++ b/tools/ui/node_modules/jsonfile/README.md
@@ -0,0 +1,230 @@
+Node.js - jsonfile
+================
+
+Easily read/write JSON files in Node.js. _Note: this module cannot be used in the browser._
+
+[](https://www.npmjs.org/package/jsonfile)
+[](https://github.com/jprichardson/node-jsonfile/actions?query=branch%3Amaster)
+[](https://ci.appveyor.com/project/jprichardson/node-jsonfile/branch/master)
+
+
+
+Why?
+----
+
+Writing `JSON.stringify()` and then `fs.writeFile()` and `JSON.parse()` with `fs.readFile()` enclosed in `try/catch` blocks became annoying.
+
+
+
+Installation
+------------
+
+ npm install --save jsonfile
+
+
+
+API
+---
+
+* [`readFile(filename, [options], callback)`](#readfilefilename-options-callback)
+* [`readFileSync(filename, [options])`](#readfilesyncfilename-options)
+* [`writeFile(filename, obj, [options], callback)`](#writefilefilename-obj-options-callback)
+* [`writeFileSync(filename, obj, [options])`](#writefilesyncfilename-obj-options)
+
+----
+
+### readFile(filename, [options], callback)
+
+`options` (`object`, default `undefined`): Pass in any [`fs.readFile`](https://nodejs.org/api/fs.html#fs_fs_readfile_path_options_callback) options or set `reviver` for a [JSON reviver](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+ - `throws` (`boolean`, default: `true`). If `JSON.parse` throws an error, pass this error to the callback.
+ If `false`, returns `null` for the object.
+
+
+```js
+const jsonfile = require('jsonfile')
+const file = '/tmp/data.json'
+jsonfile.readFile(file, function (err, obj) {
+ if (err) console.error(err)
+ console.dir(obj)
+})
+```
+
+You can also use this method with promises. The `readFile` method will return a promise if you do not pass a callback function.
+
+```js
+const jsonfile = require('jsonfile')
+const file = '/tmp/data.json'
+jsonfile.readFile(file)
+ .then(obj => console.dir(obj))
+ .catch(error => console.error(error))
+```
+
+----
+
+### readFileSync(filename, [options])
+
+`options` (`object`, default `undefined`): Pass in any [`fs.readFileSync`](https://nodejs.org/api/fs.html#fs_fs_readfilesync_path_options) options or set `reviver` for a [JSON reviver](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+- `throws` (`boolean`, default: `true`). If an error is encountered reading or parsing the file, throw the error. If `false`, returns `null` for the object.
+
+```js
+const jsonfile = require('jsonfile')
+const file = '/tmp/data.json'
+
+console.dir(jsonfile.readFileSync(file))
+```
+
+----
+
+### writeFile(filename, obj, [options], callback)
+
+`options`: Pass in any [`fs.writeFile`](https://nodejs.org/api/fs.html#fs_fs_writefile_file_data_options_callback) options or set `replacer` for a [JSON replacer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify). Can also pass in `spaces`, or override `EOL` string or set `finalEOL` flag as `false` to not save the file with `EOL` at the end.
+
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj, function (err) {
+ if (err) console.error(err)
+})
+```
+Or use with promises as follows:
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj)
+ .then(res => {
+ console.log('Write complete')
+ })
+ .catch(error => console.error(error))
+```
+
+
+**formatting with spaces:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj, { spaces: 2 }, function (err) {
+ if (err) console.error(err)
+})
+```
+
+**overriding EOL:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj, { spaces: 2, EOL: '\r\n' }, function (err) {
+ if (err) console.error(err)
+})
+```
+
+
+**disabling the EOL at the end of file:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj, { spaces: 2, finalEOL: false }, function (err) {
+ if (err) console.log(err)
+})
+```
+
+**appending to an existing JSON file:**
+
+You can use `fs.writeFile` option `{ flag: 'a' }` to achieve this.
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/mayAlreadyExistedData.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFile(file, obj, { flag: 'a' }, function (err) {
+ if (err) console.error(err)
+})
+```
+
+----
+
+### writeFileSync(filename, obj, [options])
+
+`options`: Pass in any [`fs.writeFileSync`](https://nodejs.org/api/fs.html#fs_fs_writefilesync_file_data_options) options or set `replacer` for a [JSON replacer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify). Can also pass in `spaces`, or override `EOL` string or set `finalEOL` flag as `false` to not save the file with `EOL` at the end.
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFileSync(file, obj)
+```
+
+**formatting with spaces:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFileSync(file, obj, { spaces: 2 })
+```
+
+**overriding EOL:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFileSync(file, obj, { spaces: 2, EOL: '\r\n' })
+```
+
+**disabling the EOL at the end of file:**
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/data.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFileSync(file, obj, { spaces: 2, finalEOL: false })
+```
+
+**appending to an existing JSON file:**
+
+You can use `fs.writeFileSync` option `{ flag: 'a' }` to achieve this.
+
+```js
+const jsonfile = require('jsonfile')
+
+const file = '/tmp/mayAlreadyExistedData.json'
+const obj = { name: 'JP' }
+
+jsonfile.writeFileSync(file, obj, { flag: 'a' })
+```
+
+License
+-------
+
+(MIT License)
+
+Copyright 2012-2016, JP Richardson
diff --git a/tools/ui/node_modules/jsonfile/index.js b/tools/ui/node_modules/jsonfile/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..acd0af258d09a9e54d76bf2f0f5bf90356dfacb8
--- /dev/null
+++ b/tools/ui/node_modules/jsonfile/index.js
@@ -0,0 +1,88 @@
+let _fs
+try {
+ _fs = require('graceful-fs')
+} catch (_) {
+ _fs = require('fs')
+}
+const universalify = require('universalify')
+const { stringify, stripBom } = require('./utils')
+
+async function _readFile (file, options = {}) {
+ if (typeof options === 'string') {
+ options = { encoding: options }
+ }
+
+ const fs = options.fs || _fs
+
+ const shouldThrow = 'throws' in options ? options.throws : true
+
+ let data = await universalify.fromCallback(fs.readFile)(file, options)
+
+ data = stripBom(data)
+
+ let obj
+ try {
+ obj = JSON.parse(data, options ? options.reviver : null)
+ } catch (err) {
+ if (shouldThrow) {
+ err.message = `${file}: ${err.message}`
+ throw err
+ } else {
+ return null
+ }
+ }
+
+ return obj
+}
+
+const readFile = universalify.fromPromise(_readFile)
+
+function readFileSync (file, options = {}) {
+ if (typeof options === 'string') {
+ options = { encoding: options }
+ }
+
+ const fs = options.fs || _fs
+
+ const shouldThrow = 'throws' in options ? options.throws : true
+
+ try {
+ let content = fs.readFileSync(file, options)
+ content = stripBom(content)
+ return JSON.parse(content, options.reviver)
+ } catch (err) {
+ if (shouldThrow) {
+ err.message = `${file}: ${err.message}`
+ throw err
+ } else {
+ return null
+ }
+ }
+}
+
+async function _writeFile (file, obj, options = {}) {
+ const fs = options.fs || _fs
+
+ const str = stringify(obj, options)
+
+ await universalify.fromCallback(fs.writeFile)(file, str, options)
+}
+
+const writeFile = universalify.fromPromise(_writeFile)
+
+function writeFileSync (file, obj, options = {}) {
+ const fs = options.fs || _fs
+
+ const str = stringify(obj, options)
+ // not sure if fs.writeFileSync returns anything, but just in case
+ return fs.writeFileSync(file, str, options)
+}
+
+// NOTE: do not change this export format; required for ESM compat
+// see https://github.com/jprichardson/node-jsonfile/pull/162 for details
+module.exports = {
+ readFile,
+ readFileSync,
+ writeFile,
+ writeFileSync
+}
diff --git a/tools/ui/node_modules/jsonfile/package.json b/tools/ui/node_modules/jsonfile/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7d259f3d749b4d877841756db00fb1d8ee123ad
--- /dev/null
+++ b/tools/ui/node_modules/jsonfile/package.json
@@ -0,0 +1,40 @@
+{
+ "name": "jsonfile",
+ "version": "6.2.1",
+ "description": "Easily read/write JSON files.",
+ "repository": {
+ "type": "git",
+ "url": "git@github.com:jprichardson/node-jsonfile.git"
+ },
+ "keywords": [
+ "read",
+ "write",
+ "file",
+ "json",
+ "fs",
+ "fs-extra"
+ ],
+ "author": "JP Richardson ",
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ },
+ "devDependencies": {
+ "mocha": "^8.2.0",
+ "rimraf": "^2.4.0",
+ "standard": "^16.0.1"
+ },
+ "main": "index.js",
+ "files": [
+ "index.js",
+ "utils.js"
+ ],
+ "scripts": {
+ "lint": "standard",
+ "test": "npm run lint && npm run unit",
+ "unit": "mocha"
+ }
+}
diff --git a/tools/ui/node_modules/jsonfile/utils.js b/tools/ui/node_modules/jsonfile/utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a48667ddd9902a125a884e65e7520cbc9689358
--- /dev/null
+++ b/tools/ui/node_modules/jsonfile/utils.js
@@ -0,0 +1,18 @@
+function stringify (obj, { EOL = '\n', finalEOL = true, replacer = null, spaces } = {}) {
+ const EOF = finalEOL ? EOL : ''
+ const str = JSON.stringify(obj, replacer, spaces)
+
+ if (str === undefined) {
+ throw new TypeError(`Converting ${typeof obj} value to JSON is not supported`)
+ }
+
+ return str.replace(/\n/g, EOL) + EOF
+}
+
+function stripBom (content) {
+ // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
+ if (Buffer.isBuffer(content)) content = content.toString('utf8')
+ return content.replace(/^\uFEFF/, '')
+}
+
+module.exports = { stringify, stripBom }
diff --git a/tools/ui/node_modules/jsonpointer/LICENSE.md b/tools/ui/node_modules/jsonpointer/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac32f5dfdd49682b416374dcbed58a7f17fa4e24
--- /dev/null
+++ b/tools/ui/node_modules/jsonpointer/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2015 Jan Lehnardt & Marc Bachmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/tools/ui/node_modules/jsonpointer/README.md b/tools/ui/node_modules/jsonpointer/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..81c1c3960d37a5cfe9b422def9e1e24faa8a0b1e
--- /dev/null
+++ b/tools/ui/node_modules/jsonpointer/README.md
@@ -0,0 +1,45 @@
+# JSON Pointer for Node.js
+
+This is an implementation of [JSON Pointer](https://tools.ietf.org/html/rfc6901).
+
+## CLI
+
+Looking to filter JSON from the command line? Check out [jsonpointer-cli](https://github.com/joeyespo/jsonpointer-cli).
+
+## Usage
+```javascript
+var jsonpointer = require('jsonpointer');
+var obj = { foo: 1, bar: { baz: 2}, qux: [3, 4, 5]};
+
+jsonpointer.get(obj, '/foo'); // returns 1
+jsonpointer.get(obj, '/bar/baz'); // returns 2
+jsonpointer.get(obj, '/qux/0'); // returns 3
+jsonpointer.get(obj, '/qux/1'); // returns 4
+jsonpointer.get(obj, '/qux/2'); // returns 5
+jsonpointer.get(obj, '/quo'); // returns undefined
+
+jsonpointer.set(obj, '/foo', 6); // sets obj.foo = 6;
+jsonpointer.set(obj, '/qux/-', 6) // sets obj.qux = [3, 4, 5, 6]
+
+var pointer = jsonpointer.compile('/foo')
+pointer.get(obj) // returns 1
+pointer.set(obj, 1) // sets obj.foo = 1
+```
+
+## Testing
+
+ $ npm test
+ All tests pass.
+ $
+
+[](https://github.com/janl/node-jsonpointer/actions/workflows/node.js.yml)
+
+## Author
+
+(c) 2011-2021 Jan Lehnardt & Marc Bachmann
+
+Thanks to all contributors.
+
+## License
+
+MIT License.
diff --git a/tools/ui/node_modules/jsonpointer/jsonpointer.d.ts b/tools/ui/node_modules/jsonpointer/jsonpointer.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..705bebca0aa6fc928ccf4145ca42a9c9cb7c3f90
--- /dev/null
+++ b/tools/ui/node_modules/jsonpointer/jsonpointer.d.ts
@@ -0,0 +1,35 @@
+interface JSONPointer {
+ /**
+ * Looks up a JSON pointer in an object
+ */
+ get(object: Object): any;
+
+
+ /**
+ * Set a value for a JSON pointer on object
+ */
+ set(object: Object, value: any): void;
+}
+
+
+declare namespace JSONPointer {
+ /**
+ * Looks up a JSON pointer in an object
+ */
+ function get(object: Object, pointer: string): any;
+
+
+ /**
+ * Set a value for a JSON pointer on object
+ */
+ function set(object: Object, pointer: string, value: any): void;
+
+
+ /**
+ * Builds a JSONPointer instance from a pointer value.
+ */
+ function compile(pointer: string): JSONPointer;
+}
+
+
+export = JSONPointer;
diff --git a/tools/ui/node_modules/jsonpointer/jsonpointer.js b/tools/ui/node_modules/jsonpointer/jsonpointer.js
new file mode 100644
index 0000000000000000000000000000000000000000..dad907d763f7369ac0e284e7d1fae2bd5508f477
--- /dev/null
+++ b/tools/ui/node_modules/jsonpointer/jsonpointer.js
@@ -0,0 +1,100 @@
+var hasExcape = /~/
+var escapeMatcher = /~[01]/g
+function escapeReplacer (m) {
+ switch (m) {
+ case '~1': return '/'
+ case '~0': return '~'
+ }
+ throw new Error('Invalid tilde escape: ' + m)
+}
+
+function untilde (str) {
+ if (!hasExcape.test(str)) return str
+ return str.replace(escapeMatcher, escapeReplacer)
+}
+
+function setter (obj, pointer, value) {
+ var part
+ var hasNextPart
+
+ for (var p = 1, len = pointer.length; p < len;) {
+ if (pointer[p] === 'constructor' || pointer[p] === 'prototype' || pointer[p] === '__proto__') return obj
+
+ part = untilde(pointer[p++])
+ hasNextPart = len > p
+
+ if (typeof obj[part] === 'undefined') {
+ // support setting of /-
+ if (Array.isArray(obj) && part === '-') {
+ part = obj.length
+ }
+
+ // support nested objects/array when setting values
+ if (hasNextPart) {
+ if ((pointer[p] !== '' && pointer[p] < Infinity) || pointer[p] === '-') obj[part] = []
+ else obj[part] = {}
+ }
+ }
+
+ if (!hasNextPart) break
+ obj = obj[part]
+ }
+
+ var oldValue = obj[part]
+ if (value === undefined) delete obj[part]
+ else obj[part] = value
+ return oldValue
+}
+
+function compilePointer (pointer) {
+ if (typeof pointer === 'string') {
+ pointer = pointer.split('/')
+ if (pointer[0] === '') return pointer
+ throw new Error('Invalid JSON pointer.')
+ } else if (Array.isArray(pointer)) {
+ for (const part of pointer) {
+ if (typeof part !== 'string' && typeof part !== 'number') {
+ throw new Error('Invalid JSON pointer. Must be of type string or number.')
+ }
+ }
+ return pointer
+ }
+
+ throw new Error('Invalid JSON pointer.')
+}
+
+function get (obj, pointer) {
+ if (typeof obj !== 'object') throw new Error('Invalid input object.')
+ pointer = compilePointer(pointer)
+ var len = pointer.length
+ if (len === 1) return obj
+
+ for (var p = 1; p < len;) {
+ obj = obj[untilde(pointer[p++])]
+ if (len === p) return obj
+ if (typeof obj !== 'object' || obj === null) return undefined
+ }
+}
+
+function set (obj, pointer, value) {
+ if (typeof obj !== 'object') throw new Error('Invalid input object.')
+ pointer = compilePointer(pointer)
+ if (pointer.length === 0) throw new Error('Invalid JSON pointer for set.')
+ return setter(obj, pointer, value)
+}
+
+function compile (pointer) {
+ var compiled = compilePointer(pointer)
+ return {
+ get: function (object) {
+ return get(object, compiled)
+ },
+ set: function (object, value) {
+ return set(object, compiled, value)
+ }
+ }
+}
+
+exports.get = get
+exports.set = set
+exports.compile = compile
diff --git a/tools/ui/node_modules/jsonpointer/package.json b/tools/ui/node_modules/jsonpointer/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..a832ba9fc48f08300d8e5e595409c0488217af86
--- /dev/null
+++ b/tools/ui/node_modules/jsonpointer/package.json
@@ -0,0 +1,48 @@
+{
+ "name": "jsonpointer",
+ "description": "Simple JSON Addressing.",
+ "tags": [
+ "util",
+ "simple",
+ "util",
+ "utility"
+ ],
+ "version": "5.0.1",
+ "author": "Jan Lehnardt ",
+ "contributors": [
+ "Joe Hildebrand ",
+ "Marc Bachmann "
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/janl/node-jsonpointer.git"
+ },
+ "bugs": {
+ "url": "http://github.com/janl/node-jsonpointer/issues"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ },
+ "main": "./jsonpointer",
+ "typings": "jsonpointer.d.ts",
+ "files": [
+ "jsonpointer.js",
+ "jsonpointer.d.ts"
+ ],
+ "scripts": {
+ "test": "npm run test:standard && npm run test:all",
+ "test:standard": "standard",
+ "test:all": "node test.js",
+ "semantic-release": "semantic-release pre && npm publish && semantic-release post"
+ },
+ "license": "MIT",
+ "devDependencies": {
+ "semantic-release": "^18.0.0",
+ "standard": "^16.0.4"
+ },
+ "standard": {
+ "ignore": [
+ "test.js"
+ ]
+ }
+}
diff --git a/tools/ui/node_modules/katex/LICENSE b/tools/ui/node_modules/katex/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..37c6433e3bedca7a97e08fe35d98582a5f7bac0c
--- /dev/null
+++ b/tools/ui/node_modules/katex/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2020 Khan Academy and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/tools/ui/node_modules/katex/README.md b/tools/ui/node_modules/katex/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d07a3781d65198449ac20b3fae13347ee971530
--- /dev/null
+++ b/tools/ui/node_modules/katex/README.md
@@ -0,0 +1,125 @@
+
+
+[](https://www.npmjs.com/package/katex)
+[](https://github.com/semantic-release/semantic-release)
+[](https://github.com/KaTeX/KaTeX/actions?query=workflow%3ACI)
+[](https://codecov.io/gh/KaTeX/KaTeX)
+[](https://github.com/KaTeX/KaTeX/discussions)
+[](https://www.jsdelivr.com/package/npm/katex)
+
+[](https://gitpod.io/#https://github.com/KaTeX/KaTeX)
+[](https://opencollective.com/katex)
+
+KaTeX is a fast, easy-to-use JavaScript library for TeX math rendering on the web.
+
+ * **Fast:** KaTeX renders its math synchronously and doesn't need to reflow the page. See how it compares to a competitor in [this speed test](https://www.intmath.com/cg5/katex-mathjax-comparison.php).
+ * **Print quality:** KaTeX's layout is based on Donald Knuth's TeX, the gold standard for math typesetting.
+ * **Self contained:** KaTeX has no dependencies and can easily be bundled with your website resources.
+ * **Server side rendering:** KaTeX produces the same output regardless of browser or environment, so you can pre-render expressions using Node.js and send them as plain HTML.
+
+KaTeX is compatible with all major browsers, including Chrome, Safari, Firefox, Opera, and Edge.
+
+KaTeX supports much (but not all) of LaTeX and many LaTeX packages. See the [list of supported functions](https://katex.org/docs/supported.html).
+
+Try out KaTeX [on the demo page](https://katex.org/#demo)!
+
+## Getting started
+
+### Starter template
+
+```html
+
+
+
+
+
+
+
+
+
+
+
+
+ ...
+
+```
+
+You can also [download KaTeX](https://github.com/KaTeX/KaTeX/releases) and host it yourself.
+
+For details on how to configure auto-render extension, refer to [the documentation](https://katex.org/docs/autorender.html).
+
+### API
+
+Call `katex.render` to render a TeX expression directly into a DOM element.
+For example:
+
+```js
+katex.render("c = \\pm\\sqrt{a^2 + b^2}", element, {
+ throwOnError: false
+});
+```
+
+Call `katex.renderToString` to generate an HTML string of the rendered math,
+e.g., for server-side rendering. For example:
+
+```js
+var html = katex.renderToString("c = \\pm\\sqrt{a^2 + b^2}", {
+ throwOnError: false
+});
+// '...'
+```
+
+Make sure to include the CSS and font files in both cases.
+If you are doing all rendering on the server, there is no need to include the
+JavaScript on the client.
+
+The examples above use the `throwOnError: false` option, which renders invalid
+inputs as the TeX source code in red (by default), with the error message as
+hover text. For other available options, see the
+[API documentation](https://katex.org/docs/api.html),
+[options documentation](https://katex.org/docs/options.html), and
+[handling errors documentation](https://katex.org/docs/error.html).
+
+## Demo and Documentation
+
+Learn more about using KaTeX [on the website](https://katex.org)!
+
+## Contributors
+
+### Code Contributors
+
+This project exists thanks to all the people who contribute code. If you'd like to help, see [our guide to contributing code](CONTRIBUTING.md).
+
+
+### Financial Contributors
+
+Become a financial contributor and help us sustain our community.
+
+#### Individuals
+
+
+
+#### Organizations
+
+Support this project with your organization. Your logo will show up here with a link to your website.
+
+
+
+
+
+
+
+
+
+
+
+
+## License
+
+KaTeX is licensed under the [MIT License](https://opensource.org/licenses/MIT).
diff --git a/tools/ui/node_modules/katex/cli.js b/tools/ui/node_modules/katex/cli.js
new file mode 100644
index 0000000000000000000000000000000000000000..b9e7f951d18d3e62c36368e84b38bfa7d61486a2
--- /dev/null
+++ b/tools/ui/node_modules/katex/cli.js
@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// Simple CLI for KaTeX.
+// Reads TeX from stdin, outputs HTML to stdout.
+// To run this from the repository, you must first build KaTeX by running
+// `yarn` and `yarn build`.
+
+/* eslint no-console:0 */
+
+let katex;
+try {
+ katex = require("./");
+} catch (e) {
+ console.error(
+ "KaTeX could not import, likely because dist/katex.js is missing.");
+ console.error("Please run 'yarn' and 'yarn build' before running");
+ console.error("cli.js from the KaTeX repository.");
+ console.error();
+ throw e;
+}
+const {version} = require("./package.json");
+const fs = require("fs");
+
+const {program} = require("commander");
+program.version(version);
+
+for (const prop in katex.SETTINGS_SCHEMA) {
+ if (katex.SETTINGS_SCHEMA.hasOwnProperty(prop)) {
+ const opt = katex.SETTINGS_SCHEMA[prop];
+ if (opt.cli !== false) {
+ program.option(opt.cli || "--" + prop, opt.cliDescription ||
+ opt.description, opt.cliProcessor, opt.cliDefault);
+ }
+ }
+}
+program.option("-f, --macro-file ",
+ "Read macro definitions, one per line, from the given file.")
+ .option("-i, --input ", "Read LaTeX input from the given file.")
+ .option("-o, --output ", "Write html output to the given file.");
+
+let options;
+
+function readMacros() {
+ if (options.macroFile) {
+ fs.readFile(options.macroFile, "utf-8", function(err, data) {
+ if (err) {throw err;}
+ splitMacros(data.toString().split('\n'));
+ });
+ } else {
+ splitMacros([]);
+ }
+}
+
+function splitMacros(macroStrings) {
+ // Override macros from macro file (if any)
+ // with macros from command line (if any)
+ macroStrings = macroStrings.concat(options.macro);
+
+ const macros = {};
+
+ for (const m of macroStrings) {
+ const i = m.search(":");
+ if (i !== -1) {
+ macros[m.substring(0, i).trim()] = m.substring(i + 1).trim();
+ }
+ }
+
+ options.macros = macros;
+ readInput();
+}
+
+function readInput() {
+ let input = "";
+
+ if (options.input) {
+ fs.readFile(options.input, "utf-8", function(err, data) {
+ if (err) {throw err;}
+ input = data.toString();
+ writeOutput(input);
+ });
+ } else {
+ process.stdin.on("data", function(chunk) {
+ input += chunk.toString();
+ });
+
+ process.stdin.on("end", function() {
+ writeOutput(input);
+ });
+ }
+}
+
+function writeOutput(input) {
+ // --format specifies the KaTeX output
+ const outputFile = options.output;
+ options.output = options.format;
+
+ const output = katex.renderToString(input, options) + "\n";
+
+ if (outputFile) {
+ fs.writeFile(outputFile, output, function(err) {
+ if (err) {
+ return console.log(err);
+ }
+ });
+ } else {
+ console.log(output);
+ }
+}
+
+if (require.main !== module) {
+ module.exports = program;
+} else {
+ options = program.parse(process.argv).opts();
+ readMacros();
+}
diff --git a/tools/ui/node_modules/katex/contrib/auto-render/README.md b/tools/ui/node_modules/katex/contrib/auto-render/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea793f1c09c0bef0a9dc76884d91183a208a25f2
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/auto-render/README.md
@@ -0,0 +1,8 @@
+# Auto-render extension
+
+This is an extension to automatically render all of the math inside of text. It
+searches all of the text nodes in a given element for the given delimiters, and
+renders the math in place.
+
+See [Auto-render extension documentation](https://katex.org/docs/autorender.html)
+for more information.
diff --git a/tools/ui/node_modules/katex/contrib/auto-render/auto-render.ts b/tools/ui/node_modules/katex/contrib/auto-render/auto-render.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d77820171669bd111d349f15d87eb364e987383a
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/auto-render/auto-render.ts
@@ -0,0 +1,164 @@
+/* eslint no-console:0 */
+
+import katex from "katex";
+import splitAtDelimiters from "./splitAtDelimiters";
+import type {DelimiterSpec} from "./splitAtDelimiters";
+
+interface RenderMathInElementOptions {
+ delimiters?: DelimiterSpec[];
+ preProcess?: (math: string) => string;
+ ignoredTags?: string[];
+ ignoredClasses?: string[];
+ errorCallback?: (msg: string, err: Error) => void;
+ displayMode?: boolean;
+ macros?: Record;
+}
+
+interface RenderMathInElementOptionsCopy {
+ delimiters: DelimiterSpec[];
+ preProcess?: (math: string) => string;
+ ignoredTags: Set;
+ ignoredClasses: string[];
+ errorCallback: (msg: string, err: Error) => void;
+ displayMode?: boolean;
+ macros?: Record;
+}
+
+/* Note: optionsCopy is mutated by this method. If it is ever exposed in the
+ * API, we should copy it before mutating.
+ */
+const renderMathInText = function(
+ text: string,
+ optionsCopy: RenderMathInElementOptionsCopy
+) {
+ const data = splitAtDelimiters(text, optionsCopy.delimiters);
+ if (data.length === 1 && data[0].type === 'text') {
+ // There is no formula in the text.
+ // Let's return null which means there is no need to replace
+ // the current text node with a new one.
+ return null;
+ }
+
+ const fragment = document.createDocumentFragment();
+
+ for (let i = 0; i < data.length; i++) {
+ if (data[i].type === "text") {
+ fragment.appendChild(document.createTextNode(data[i].data));
+ } else {
+ const span = document.createElement("span");
+ let math = data[i].data;
+ // Override any display mode defined in the settings with that
+ // defined by the text itself
+ optionsCopy.displayMode = data[i].display;
+ try {
+ if (optionsCopy.preProcess) {
+ math = optionsCopy.preProcess(math);
+ }
+ katex.render(math, span, optionsCopy);
+ } catch (e) {
+ if (!(e instanceof katex.ParseError)) {
+ throw e;
+ }
+ optionsCopy.errorCallback(
+ "KaTeX auto-render: Failed to parse `" + data[i].data +
+ "` with ",
+ e
+ );
+ fragment.appendChild(document.createTextNode(data[i].rawData!));
+ continue;
+ }
+ fragment.appendChild(span);
+ }
+ }
+
+ return fragment;
+};
+
+const renderElem = function(
+ elem: HTMLElement,
+ optionsCopy: RenderMathInElementOptionsCopy
+) {
+ for (let i = 0; i < elem.childNodes.length; i++) {
+ const childNode = elem.childNodes[i];
+ if (childNode.nodeType === 3) {
+ // Text node
+ // Concatenate all sibling text nodes.
+ // Webkit browsers split very large text nodes into smaller ones,
+ // so the delimiters may be split across different nodes.
+ let textContentConcat = childNode.textContent ?? "";
+ let sibling = childNode.nextSibling;
+ let nSiblings = 0;
+ while (sibling && (sibling.nodeType === Node.TEXT_NODE)) {
+ textContentConcat += sibling.textContent ?? "";
+ sibling = sibling.nextSibling;
+ nSiblings++;
+ }
+ const frag = renderMathInText(textContentConcat, optionsCopy);
+ if (frag) {
+ // Remove extra text nodes
+ for (let j = 0; j < nSiblings; j++) {
+ childNode.nextSibling!.remove();
+ }
+ i += frag.childNodes.length - 1;
+ elem.replaceChild(frag, childNode);
+ } else {
+ // If the concatenated text does not contain math
+ // the siblings will not either
+ i += nSiblings;
+ }
+ } else if (childNode.nodeType === 1) {
+ // Element node
+ const className = ' ' + (childNode as HTMLElement).className + ' ';
+ const shouldRender = !optionsCopy.ignoredTags.has(
+ childNode.nodeName.toLowerCase()) &&
+ optionsCopy.ignoredClasses.every(
+ (x: string) => !className.includes(' ' + x + ' '));
+
+ if (shouldRender) {
+ renderElem(childNode as HTMLElement, optionsCopy);
+ }
+ }
+ // Otherwise, it's something else, and ignore it.
+ }
+};
+
+const renderMathInElement = function(elem: HTMLElement, options?: RenderMathInElementOptions) {
+ if (!elem) {
+ throw new Error("No element provided to render");
+ }
+
+ const optionsCopy: Partial = {};
+
+ Object.assign(optionsCopy, options);
+
+ // default options
+ optionsCopy.delimiters = optionsCopy.delimiters || [
+ {left: "$$", right: "$$", display: true},
+ {left: "\\(", right: "\\)", display: false},
+ // LaTeX uses $…$, but it ruins the display of normal `$` in text:
+ // {left: "$", right: "$", display: false},
+ // $ must come after $$
+
+ // Render AMS environments even if outside $$…$$ delimiters.
+ {left: "\\begin{equation}", right: "\\end{equation}", display: true},
+ {left: "\\begin{align}", right: "\\end{align}", display: true},
+ {left: "\\begin{alignat}", right: "\\end{alignat}", display: true},
+ {left: "\\begin{gather}", right: "\\end{gather}", display: true},
+ {left: "\\begin{CD}", right: "\\end{CD}", display: true},
+
+ {left: "\\[", right: "\\]", display: true},
+ ];
+ optionsCopy.ignoredTags = new Set(options?.ignoredTags || [
+ "script", "noscript", "style", "textarea", "pre", "code", "option",
+ ]);
+ optionsCopy.ignoredClasses = optionsCopy.ignoredClasses || [];
+ optionsCopy.errorCallback = optionsCopy.errorCallback || console.error;
+
+ // Enable sharing of global macros defined via `\gdef` between different
+ // math elements within a single call to `renderMathInElement`.
+ optionsCopy.macros = optionsCopy.macros || {};
+
+ renderElem(elem, optionsCopy as RenderMathInElementOptionsCopy);
+};
+
+export default renderMathInElement;
diff --git a/tools/ui/node_modules/katex/contrib/auto-render/index.html b/tools/ui/node_modules/katex/contrib/auto-render/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..cf5c209c97710a4af41203b6570510063b56c055
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/auto-render/index.html
@@ -0,0 +1,57 @@
+
+
+
+
+
+ Auto-render test
+
+
+
+
+
+
+ This is some text $math \frac12$ other text $\unsupported$
+
+ Other node \[ \text{displaymath} \frac{1}{2} \] blah $$ \int_2^3 $$
+
+ and some more text \(and math\) blah. And $math with a
+ \$ sign$.
+
+ Stuff in a $pre tag$
+
+
An AMS environment without $$…$$ delimiters.
+
\begin{equation} \begin{split} a &=b+c\\ &=e+f \end{split} \end{equation}
+
element containing node, or null if not found.
+function closestKatex(node: Node): Element | null | undefined {
+ // If node is a Text Node, for example, go up to containing Element,
+ // where we can apply the `closest` method.
+ const element: Element | null | undefined =
+ (node instanceof Element ? node : node.parentElement);
+ return element && element.closest('.katex');
+}
+
+// Global copy handler to modify behavior on/within .katex elements.
+document.addEventListener('copy', function(event: ClipboardEvent) {
+ const selection = window.getSelection();
+ if (!selection || selection.isCollapsed || !event.clipboardData) {
+ return; // default action OK if selection is empty or unchangeable
+ }
+ const clipboardData = event.clipboardData;
+ const range = selection.getRangeAt(0);
+
+ // When start point is within a formula, expand to entire formula.
+ const startKatex = closestKatex(range.startContainer);
+ if (startKatex) {
+ range.setStartBefore(startKatex);
+ }
+
+ // Similarly, when end point is within a formula, expand to entire formula.
+ const endKatex = closestKatex(range.endContainer);
+ if (endKatex) {
+ range.setEndAfter(endKatex);
+ }
+
+ const fragment = range.cloneContents();
+ if (!fragment.querySelector('.katex-mathml')) {
+ return; // default action OK if no .katex-mathml elements
+ }
+
+ const htmlContents = Array.prototype.map.call(fragment.childNodes,
+ (el) => (el instanceof Text ? el.textContent : el.outerHTML)
+ ).join('');
+
+ // Preserve usual HTML copy/paste behavior.
+ clipboardData.setData('text/html', htmlContents);
+ // Rewrite plain-text version.
+ clipboardData.setData('text/plain',
+ katexReplaceWithTex(fragment).textContent);
+ // Prevent normal copy handling.
+ event.preventDefault();
+});
diff --git a/tools/ui/node_modules/katex/contrib/copy-tex/index.html b/tools/ui/node_modules/katex/contrib/copy-tex/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fa59d27326120b8713cd107e958889fa4fc4f68d
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/copy-tex/index.html
@@ -0,0 +1,38 @@
+
+
+
+
+
+
Copy-tex test
+
+
+
+
+
+
+
Copy-tex test
+
Try copy/pasting some of the text below!
+
+ Here is some \(\KaTeX\) math: $$ x^2+y^2=z^2 $$
+ The variables are \(x\), \(y\), and \(z\),
+ which are all in \(\mathbb{R}^+\).
+ Q.E.D.
+
+
+
+
diff --git a/tools/ui/node_modules/katex/contrib/copy-tex/katex2tex.ts b/tools/ui/node_modules/katex/contrib/copy-tex/katex2tex.ts
new file mode 100644
index 0000000000000000000000000000000000000000..588bed262e505d649e497110f77df477073a734f
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/copy-tex/katex2tex.ts
@@ -0,0 +1,60 @@
+
+export interface CopyDelimiters {
+ inline: [string, string];
+ display: [string, string];
+}
+
+// Set these to how you want inline and display math to be delimited.
+export const defaultCopyDelimiters: CopyDelimiters = {
+ inline: ['$', '$'], // alternative: ['\(', '\)']
+ display: ['$$', '$$'], // alternative: ['\[', '\]']
+};
+
+// Replace .katex elements with their TeX source (
element).
+// Modifies fragment in-place. Useful for writing your own 'copy' handler,
+// as in copy-tex.js.
+export function katexReplaceWithTex(
+ fragment: DocumentFragment,
+ copyDelimiters: CopyDelimiters = defaultCopyDelimiters
+): DocumentFragment {
+ // Remove .katex-html blocks that are preceded by .katex-mathml blocks
+ // (which will get replaced below).
+ const katexHtml = fragment.querySelectorAll('.katex-mathml + .katex-html');
+ for (let i = 0; i < katexHtml.length; i++) {
+ const element = katexHtml[i];
+ if (element.remove) {
+ element.remove();
+ } else if (element.parentNode) {
+ element.parentNode.removeChild(element);
+ }
+ }
+ // Replace .katex-mathml elements with their annotation (TeX source)
+ // descendant, with inline delimiters.
+ const katexMathml = fragment.querySelectorAll('.katex-mathml');
+ for (let i = 0; i < katexMathml.length; i++) {
+ const element = katexMathml[i];
+ const texSource = element.querySelector('annotation');
+ if (texSource) {
+ if (element.replaceWith) {
+ element.replaceWith(texSource);
+ } else if (element.parentNode) {
+ element.parentNode.replaceChild(texSource, element);
+ }
+ texSource.innerHTML = copyDelimiters.inline[0] +
+ texSource.innerHTML + copyDelimiters.inline[1];
+ }
+ }
+ // Switch display math to display delimiters.
+ const displays = fragment.querySelectorAll('.katex-display annotation');
+ for (let i = 0; i < displays.length; i++) {
+ const element = displays[i];
+ element.innerHTML = copyDelimiters.display[0] +
+ element.innerHTML.substr(copyDelimiters.inline[0].length,
+ element.innerHTML.length - copyDelimiters.inline[0].length
+ - copyDelimiters.inline[1].length)
+ + copyDelimiters.display[1];
+ }
+ return fragment;
+}
+
+export default katexReplaceWithTex;
diff --git a/tools/ui/node_modules/katex/contrib/mathtex-script-type/README.md b/tools/ui/node_modules/katex/contrib/mathtex-script-type/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa38f5fb08e298a1ee1263388217d2490ace2699
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/mathtex-script-type/README.md
@@ -0,0 +1,38 @@
+# `math/tex` Custom Script Type Extension
+
+This is an extension to automatically display code inside `script` tags with `type=math/tex` using KaTeX.
+This script type is commonly used by MathJax, so this can be used to support compatibility with MathJax.
+
+### Usage
+
+This extension isn't part of KaTeX proper, so the script should be separately
+included in the page, in addition to KaTeX.
+
+Load the extension by adding the following line to your HTML file.
+
+```html
+
+```
+You can download the script and use it locally, or from a local KaTeX installation instead.
+
+For example, in the following simple page, we first load KaTeX as usual.
+Then, in the body, we use a `math/tex` script to typeset the equation `x+\sqrt{1-x^2}`.
+
+
+```html
+
+
+
+
+
+
+
+
+
+
+
+```
+
+ECMAScript module is also available:
+```html
+
diff --git a/tools/ui/node_modules/katex/contrib/mathtex-script-type/mathtex-script-type.js b/tools/ui/node_modules/katex/contrib/mathtex-script-type/mathtex-script-type.js
new file mode 100644
index 0000000000000000000000000000000000000000..732db698adcf474919b5868e553f534d2f2e6b8e
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/mathtex-script-type/mathtex-script-type.js
@@ -0,0 +1,23 @@
+import katex from "katex";
+
+let scripts = document.body.getElementsByTagName("script");
+scripts = Array.prototype.slice.call(scripts);
+scripts.forEach(function(script) {
+ if (!script.type || !script.type.match(/math\/tex/i)) {
+ return -1;
+ }
+ const display =
+ (script.type.match(/mode\s*=\s*display(;|\s|\n|$)/) != null);
+
+ const katexElement = document.createElement(display ? "div" : "span");
+ katexElement.setAttribute("class",
+ display ? "equation" : "inline-equation");
+ try {
+ katex.render(script.text, katexElement, {displayMode: display});
+ } catch (err) {
+ // eslint-disable-next-line no-console
+ console.error(err);
+ katexElement.textContent = script.text;
+ }
+ script.parentNode.replaceChild(katexElement, script);
+});
diff --git a/tools/ui/node_modules/katex/contrib/mhchem/README.md b/tools/ui/node_modules/katex/contrib/mhchem/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fba80f09eded0218309ec4e1d413d1c4922f54bf
--- /dev/null
+++ b/tools/ui/node_modules/katex/contrib/mhchem/README.md
@@ -0,0 +1,23 @@
+# mhchem extension
+
+This extension adds to KaTeX the `\ce` and `\pu` functions from the [mhchem](https://mhchem.github.io/MathJax-mhchem/) package.
+
+### Usage
+
+This extension isn't part of core KaTeX, so the script should be separately included. Write the following line into the HTML page's ``. Place it *after* the line that calls `katex.js`, and if you make use of the [auto-render](https://katex.org/docs/autorender.html) extension, place it *before* the line that calls `auto-render.js`.
+
+```html
+
+```
+
+If you remove the `defer` attribute from this tag, then you must also remove the `defer` attribute from the `
+
+
+
+
+ ...
+
+
+# is-promise
+
+ Test whether an object looks like a promises-a+ promise
+
+ [](https://travis-ci.org/then/is-promise)
+ [](https://david-dm.org/then/is-promise)
+ [](https://www.npmjs.org/package/is-promise)
+
+
+
+## Installation
+
+ $ npm install is-promise
+
+You can also use it client side via npm.
+
+## API
+
+```typescript
+import isPromise from 'is-promise';
+
+isPromise(Promise.resolve());//=>true
+isPromise({then:function () {...}});//=>true
+isPromise(null);//=>false
+isPromise({});//=>false
+isPromise({then: true})//=>false
+```
+
+## License
+
+ MIT
diff --git a/tools/ui/node_modules/is-reference/README.md b/tools/ui/node_modules/is-reference/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a697c5bcd131a6e895ad76c464d83e899586212d
--- /dev/null
+++ b/tools/ui/node_modules/is-reference/README.md
@@ -0,0 +1,61 @@
+# is-reference
+
+Utility for determining whether an AST node is a reference.
+
+`foo` is a reference in these cases:
+
+```js
+console.log(foo);
+var foo;
+function foo() {}
+function bar(foo) {}
+export { foo as x };
+```
+
+`foo` is *not* a reference in these cases:
+
+```js
+var obj = { foo: 1 };
+console.log(obj.foo);
+export { x as foo };
+```
+
+In all cases, `foo` is an `Identifier` node, but the two kinds must be treated differently for the purposes of scope analysis etc. (The examples are non-exhaustive.)
+
+
+## Installation
+
+```bash
+npm install is-reference
+```
+
+
+## Usage
+
+Example using [Acorn](https://github.com/ternjs/acorn) and [estree-walker](https://github.com/Rich-Harris/estree-walker):
+
+```js
+import { parse } from 'acorn';
+import { walk } from 'estree-walker';
+import is_reference from 'is-reference';
+
+const identifiers = [];
+const references = [];
+
+const ast = parse(`var a = b.c;`);
+
+walk(ast, {
+ enter(node, parent) {
+ if (node.type === 'Identifier') identifiers.push(node);
+ if (is_reference(node, parent)) references.push(node);
+ }
+});
+
+identifiers.forEach(node => console.log(node.name)); // a, b, c
+references.forEach(node => console.log(node.name)); // a, b
+```
+
+
+## License
+
+MIT
diff --git a/tools/ui/node_modules/is-reference/package.json b/tools/ui/node_modules/is-reference/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..a9425d9f484fa84a7402cbbfce9cc07eb630a9fa
--- /dev/null
+++ b/tools/ui/node_modules/is-reference/package.json
@@ -0,0 +1,48 @@
+{
+ "name": "is-reference",
+ "version": "3.0.3",
+ "description": "Determine whether an AST node is a reference",
+ "type": "module",
+ "module": "src/index.js",
+ "types": "types/index.d.ts",
+ "exports": {
+ "types": "./types/index.d.ts",
+ "import": "./src/index.js"
+ },
+ "files": [
+ "src",
+ "types"
+ ],
+ "scripts": {
+ "test": "uvu",
+ "prepublishOnly": "npm test && dts-buddy"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/Rich-Harris/is-reference.git"
+ },
+ "keywords": [
+ "ast",
+ "javascript",
+ "estree",
+ "acorn"
+ ],
+ "author": "Rich Harris",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/Rich-Harris/is-reference/issues"
+ },
+ "homepage": "https://github.com/Rich-Harris/is-reference#readme",
+ "dependencies": {
+ "@types/estree": "^1.0.6"
+ },
+ "devDependencies": {
+ "acorn": "^8.0.5",
+ "acorn-class-fields": "^1.0.0",
+ "acorn-static-class-features": "^1.0.0",
+ "dts-buddy": "^0.5.3",
+ "estree-walker": "^3.0.0",
+ "typescript": "^5.6.3",
+ "uvu": "^0.5.6"
+ }
+}
diff --git a/tools/ui/node_modules/is-reference/src/index.js b/tools/ui/node_modules/is-reference/src/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..23f8714ce3461ecdd91342d9b2598dc8afb6e217
--- /dev/null
+++ b/tools/ui/node_modules/is-reference/src/index.js
@@ -0,0 +1,51 @@
+/** @import { Node } from 'estree' */
+
+/**
+ * @param {Node} node
+ * @param {Node} parent
+ * @returns {boolean}
+ */
+export default function is_reference(node, parent) {
+ if (node.type === 'MemberExpression') {
+ return !node.computed && is_reference(node.object, node);
+ }
+
+ if (node.type !== 'Identifier') return false;
+
+ switch (parent?.type) {
+ // disregard `bar` in `foo.bar`
+ case 'MemberExpression':
+ return parent.computed || node === parent.object;
+
+ // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+ case 'MethodDefinition':
+ return parent.computed;
+
+ // disregard the `meta` in `import.meta`
+ case 'MetaProperty':
+ return parent.meta === node;
+
+ // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+ case 'PropertyDefinition':
+ return parent.computed || node === parent.value;
+
+ // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+ case 'Property':
+ return parent.computed || node === parent.value;
+
+ // disregard the `bar` in `export { foo as bar }` or
+ // the foo in `import { foo as bar }`
+ case 'ExportSpecifier':
+ case 'ImportSpecifier':
+ return node === parent.local;
+
+ // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+ case 'LabeledStatement':
+ case 'BreakStatement':
+ case 'ContinueStatement':
+ return false;
+
+ default:
+ return true;
+ }
+}
diff --git a/tools/ui/node_modules/is-reference/types/index.d.ts b/tools/ui/node_modules/is-reference/types/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..56f82d6722f404b7e450bc81a283d247969098de
--- /dev/null
+++ b/tools/ui/node_modules/is-reference/types/index.d.ts
@@ -0,0 +1,8 @@
+declare module 'is-reference' {
+ import type { Node } from 'estree';
+ export default function is_reference(node: Node, parent: Node): boolean;
+
+ export {};
+}
+
+//# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/tools/ui/node_modules/is-reference/types/index.d.ts.map b/tools/ui/node_modules/is-reference/types/index.d.ts.map
new file mode 100644
index 0000000000000000000000000000000000000000..664a3f0d8d06944c1dcf475ba9f1ad6484b1bc51
--- /dev/null
+++ b/tools/ui/node_modules/is-reference/types/index.d.ts.map
@@ -0,0 +1,9 @@
+{
+ "version": 3,
+ "file": "index.d.ts",
+ "names": [],
+ "sources": [],
+ "sourcesContent": [],
+ "mappings": "",
+ "ignoreList": []
+}
\ No newline at end of file
diff --git a/tools/ui/node_modules/is-regex/.editorconfig b/tools/ui/node_modules/is-regex/.editorconfig
new file mode 100644
index 0000000000000000000000000000000000000000..ba546cdd8837ca06ccf0d412d860767c3620bd9c
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/.editorconfig
@@ -0,0 +1,23 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 200
+
+[CHANGELOG.md]
+indent_style = space
+indent_size = 2
+
+[*.json]
+max_line_length = off
+
+[Makefile]
+max_line_length = off
+
+[CHANGELOG.md]
+max_line_length = off
diff --git a/tools/ui/node_modules/is-regex/.eslintrc b/tools/ui/node_modules/is-regex/.eslintrc
new file mode 100644
index 0000000000000000000000000000000000000000..75a9c5e67ce7ca14e311512a7f4cd9e7bd5ebbd4
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/.eslintrc
@@ -0,0 +1,10 @@
+{
+ "root": true,
+
+ "extends": "@ljharb",
+
+ "rules": {
+ "func-style": 0,
+ "id-length": [1],
+ },
+}
diff --git a/tools/ui/node_modules/is-regex/.nycrc b/tools/ui/node_modules/is-regex/.nycrc
new file mode 100644
index 0000000000000000000000000000000000000000..a69aa2d8273d8c598f8e3aa5c8d779e28d63862f
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/.nycrc
@@ -0,0 +1,10 @@
+{
+ "all": true,
+ "check-coverage": false,
+ "reporter": ["text-summary", "text", "html", "json"],
+ "exclude": [
+ "coverage",
+ "test",
+ "test-corejs.js"
+ ]
+}
diff --git a/tools/ui/node_modules/is-regex/CHANGELOG.md b/tools/ui/node_modules/is-regex/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..85beee84b50cb6693b9b8f77630adbc9a9ad68db
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/CHANGELOG.md
@@ -0,0 +1,233 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.2.1](https://github.com/inspect-js/is-regex/compare/v1.2.0...v1.2.1) - 2024-12-11
+
+### Commits
+
+- [Refactor] use `call-bound` directly [`dbabfe3`](https://github.com/inspect-js/is-regex/commit/dbabfe369261f4940f8ca059e9d452fed01e6969)
+- [Deps] update `call-bind`, `gopd` [`d5343a0`](https://github.com/inspect-js/is-regex/commit/d5343a0e05ac3c65243b29f740c7540480ad23e7)
+- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/tsconfig` [`cc081eb`](https://github.com/inspect-js/is-regex/commit/cc081eb891b075440188c3f5240b2051090f1036)
+
+## [v1.2.0](https://github.com/inspect-js/is-regex/compare/v1.1.4...v1.2.0) - 2024-11-29
+
+### Fixed
+
+- [Tests] allow tests to pass if zero traps are triggered [`#35`](https://github.com/inspect-js/is-regex/issues/35)
+
+### Commits
+
+- [actions] reuse common workflows [`be7bf6a`](https://github.com/inspect-js/is-regex/commit/be7bf6af175271e9db74e092d636307f6cf5e848)
+- [New] add types [`39066a4`](https://github.com/inspect-js/is-regex/commit/39066a426da0f0c597b888c3c839fb2efc2bf613)
+- [meta] use `npmignore` to autogenerate an npmignore file [`8938588`](https://github.com/inspect-js/is-regex/commit/89385885c2da891644e07220b4407f760c3dd629)
+- [Refactor] reorganize code [`2f76f26`](https://github.com/inspect-js/is-regex/commit/2f76f26e0008a01a2f9a849dc2687cf3e3146f3e)
+- [actions] split out node 10-20, and 20+ [`8c9aedf`](https://github.com/inspect-js/is-regex/commit/8c9aedf2cd9b3fd4ee045d747580265de223b4b2)
+- [meta] better `eccheck` command [`6b39408`](https://github.com/inspect-js/is-regex/commit/6b39408bc4cce49ac85de70fba4a843da4b78b84)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`e38cf3c`](https://github.com/inspect-js/is-regex/commit/e38cf3c4e5b234c9a0d64fcf75e45df9b2416557)
+- [actions] update codecov uploader [`487c75d`](https://github.com/inspect-js/is-regex/commit/487c75da7bbc2d977c2aed68815e7a58d269011f)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `core-js`, `foreach`, `tape` [`0d7da87`](https://github.com/inspect-js/is-regex/commit/0d7da87be90b637c094abfd9e68568097d391e38)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `core-js`, `tape` [`c1c1198`](https://github.com/inspect-js/is-regex/commit/c1c1198143feaadee0370b78f7fd878e64e57a58)
+- [actions] update rebase action to use reusable workflow [`213646e`](https://github.com/inspect-js/is-regex/commit/213646e1e9b5211bf621ccaaaa29f03b706b139c)
+- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `core-js`, `npmignore`, `tape` [`0a44e77`](https://github.com/inspect-js/is-regex/commit/0a44e77855db0ee8077f8b4351164fa500ba0d1f)
+- [Refactor] use `hasown` [`d939332`](https://github.com/inspect-js/is-regex/commit/d939332c57cf46b95bc45e721fb66db64cf4743a)
+- [Deps] update `call-bind`, `has-tostringtag` [`46bfdc9`](https://github.com/inspect-js/is-regex/commit/46bfdc9226df0495b5eb4e753e3f61e9a648cf44)
+- [Tests] use `for-each` instead of `foreach` [`138b3f2`](https://github.com/inspect-js/is-regex/commit/138b3f2e6340eb4b6caf62981b0a1f59e960cbc9)
+- [Tests] replace `aud` with `npm audit` [`37ed80a`](https://github.com/inspect-js/is-regex/commit/37ed80a3a5eeec2312f45956bc928fc7937480b8)
+- [Deps] update `gopd` [`6fd4097`](https://github.com/inspect-js/is-regex/commit/6fd4097f23c3f031d0e659b29174216bed7b4f0f)
+- [Dev Deps] update `core-js` [`97c1c60`](https://github.com/inspect-js/is-regex/commit/97c1c6044684f8a661055f4614ab2dd58fbfcc2b)
+- [Dev Deps] add missing peer dep [`7329b8e`](https://github.com/inspect-js/is-regex/commit/7329b8edc9d9440439f190704f03740c853d15da)
+
+## [v1.1.4](https://github.com/inspect-js/is-regex/compare/v1.1.3...v1.1.4) - 2021-08-05
+
+### Commits
+
+- [Dev Deps] update `auto-changelog`, `core-js`, `eslint`, `tape` [`4b17cad`](https://github.com/inspect-js/is-regex/commit/4b17cad8496b1ae621b18335fa3afe94d0c65e83)
+- [Refactor] use `has-tostringtag` to behave correctly in the presence of symbol shams [`2dad4af`](https://github.com/inspect-js/is-regex/commit/2dad4afffa15f07cbbf7675b77d1f650c92652c4)
+
+## [v1.1.3](https://github.com/inspect-js/is-regex/compare/v1.1.2...v1.1.3) - 2021-05-07
+
+### Commits
+
+- [actions] use `node/install` instead of `node/run`; use `codecov` action [`c681ab9`](https://github.com/inspect-js/is-regex/commit/c681ab99c07f8b3b7ae5f652b3105a30bce94f69)
+- [Fix] do not use `Object.prototype.toString` when `Symbol.toStringTag` is shammed [`ca019fd`](https://github.com/inspect-js/is-regex/commit/ca019fdb828dc7d32e323213403ac9995d8604e3)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`605a66f`](https://github.com/inspect-js/is-regex/commit/605a66f278900f1c8ae9d1dfcec31e5f61b10ad3)
+- [readme] add actions and codecov badges [`8d7c6f0`](https://github.com/inspect-js/is-regex/commit/8d7c6f0e007bd982f21b958e0abc98b8a84e2a24)
+- [meta] use `prepublishOnly` script for npm 7+ [`8e50e91`](https://github.com/inspect-js/is-regex/commit/8e50e91f51aa5038745526710ef2e030527982a7)
+- [Deps] update `has-symbols` [`4742c81`](https://github.com/inspect-js/is-regex/commit/4742c81260c3db9a8c9ef57110981fb6175f58e0)
+
+## [v1.1.2](https://github.com/inspect-js/is-regex/compare/v1.1.1...v1.1.2) - 2021-02-01
+
+### Commits
+
+- [Tests] migrate tests to Github Actions [`cc1686e`](https://github.com/inspect-js/is-regex/commit/cc1686e25f446ca6948f43b3f180d6e55e31fb4e)
+- [readme] fix repo URLs; remove travis badge [`d1d1da6`](https://github.com/inspect-js/is-regex/commit/d1d1da647bb4e91589606f12470cd27a47b3bb81)
+- [meta] do not publish github action workflow files [`9f84b99`](https://github.com/inspect-js/is-regex/commit/9f84b993a995f057b4d2d097ef47b1ff9c84115d)
+- [Tests] run `nyc` on all tests [`c37aab9`](https://github.com/inspect-js/is-regex/commit/c37aab9d332c4834b08ada94736c45ab1d39cd2f)
+- [Robustness] use `call-bind` [`fbb61bf`](https://github.com/inspect-js/is-regex/commit/fbb61bf3e19ccc178e6ed1e0d7ab9cc7c7167393)
+- [actions] add "Allow Edits" workflow [`9022b53`](https://github.com/inspect-js/is-regex/commit/9022b53cb05b0f105cd179800cf96e055b249f08)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog` [`d60f28f`](https://github.com/inspect-js/is-regex/commit/d60f28f7f2fb21dade7bce302b3e0246206423d3)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`2c35c43`](https://github.com/inspect-js/is-regex/commit/2c35c437edf3eeb37129eea2404d8f465d27620f)
+- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`1009e25`](https://github.com/inspect-js/is-regex/commit/1009e259d49a63753dc6e79e2b876a30c00c6de6)
+- [meta] gitignore coverage output [`3b5fa9e`](https://github.com/inspect-js/is-regex/commit/3b5fa9ed2882c65ee81dff979f79f1a2751d3772)
+- [actions] update workflows [`1843ef6`](https://github.com/inspect-js/is-regex/commit/1843ef65b8b8c24a44e91bc4ed5ee60dffc31c2d)
+
+## [v1.1.1](https://github.com/inspect-js/is-regex/compare/v1.1.0...v1.1.1) - 2020-08-03
+
+### Commits
+
+- [Performance] Re-add lastIndex check to improve performance [`d8495cd`](https://github.com/inspect-js/is-regex/commit/d8495cd22d475ddca250818921b6088f631c1972)
+- [Dev Deps] update `auto-changelog`, `eslint` [`778fa6b`](https://github.com/inspect-js/is-regex/commit/778fa6b9d2b182ee6d73993e103532855e956f85)
+
+## [v1.1.0](https://github.com/inspect-js/is-regex/compare/v1.0.5...v1.1.0) - 2020-06-03
+
+### Commits
+
+- [New] use `badStringifier`‑based RegExp detection [`31eff67`](https://github.com/inspect-js/is-regex/commit/31eff673243d65c3d6c05848c0eb52f5380f1be3)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`fc91458`](https://github.com/inspect-js/is-regex/commit/fc914588187b8bb00d8d792c84f06a6e15d883c1)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape`; add `safe-publish-latest` [`d43ed83`](https://github.com/inspect-js/is-regex/commit/d43ed83db54ea727bb0b1b77a50af79d1edb8a6d)
+- [Dev Deps] update `auto-changelog`, `tape`; add `aud` [`56647d1`](https://github.com/inspect-js/is-regex/commit/56647d196be34ef3c118ad67726e75169fbcb875)
+- [meta] only run `aud` on prod deps [`e0865b8`](https://github.com/inspect-js/is-regex/commit/e0865b8360b0ac1b9d17b7b81ae5f339e5c9036b)
+
+## [v1.0.5](https://github.com/inspect-js/is-regex/compare/v1.0.4...v1.0.5) - 2019-12-15
+
+### Commits
+
+- [Tests] use shared travis-ci configs [`af728b2`](https://github.com/inspect-js/is-regex/commit/af728b21c5cc9e41234fb4015594bffdcfff597c)
+- [Tests] remove `jscs` [`1b8cfe8`](https://github.com/inspect-js/is-regex/commit/1b8cfe8cfb14820c196775f19d370276e4034791)
+- [meta] add `auto-changelog` [`c3131d8`](https://github.com/inspect-js/is-regex/commit/c3131d8ab5d06ea5fa05a4bb2ad28bbfb81668ad)
+- [Tests] up to `node` `v8.1`, `v7.10`, `v6.11`, `v4.8`; newer npm fails on older nodes [`660b658`](https://github.com/inspect-js/is-regex/commit/660b6585d1a9607dbdae879b70ce2f6a5684616c)
+- [Tests] up to `node` `v9.3`, `v8.9`, `v6.12`; use `nvm install-latest-npm`; pin included builds to LTS [`7c25218`](https://github.com/inspect-js/is-regex/commit/7c25218d540ab17c18e4ae333677c5725806a778)
+- [Tests] up to `node` `v12.10`, `v11.15`, `v10.16`, `v8.16`, `v6.17` [`fa95547`](https://github.com/inspect-js/is-regex/commit/fa955478950a5ba0a920010d5daaa29487500b30)
+- [meta] remove unused Makefile and associated utilities [`9fd2a29`](https://github.com/inspect-js/is-regex/commit/9fd2a29dc57ed125f3d61e94f6254a9dd8ee0044)
+- [Tests] up to `node` `v11.3`, `v10.14`, `v8.14`, `v6.15` [`7f2ac41`](https://github.com/inspect-js/is-regex/commit/7f2ac41ef5dc4d53bfe2fb1c24486c688a2537bd)
+- [Tests] up to `node` `v10.0`, `v9.11`, `v8.11`, `v6.14`, `v4.9` [`6fa2b0f`](https://github.com/inspect-js/is-regex/commit/6fa2b0fe171a5b02086a06679a92d989e83a8b8e)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`697e1de`](https://github.com/inspect-js/is-regex/commit/697e1de1c9e69f08e591cc0040d81fdbbde6fe4e)
+- [actions] add automatic rebasing / merge commit blocking [`ad86dc9`](https://github.com/inspect-js/is-regex/commit/ad86dc97a52e4f66fbfb3b8c9c78da3963588b54)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `jscs`, `nsp`, `replace`, `semver`, `tape` [`5c99c8e`](https://github.com/inspect-js/is-regex/commit/5c99c8e384d5ce2ef434be5853c301477cf35456)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `replace`, `semver`, `tape` [`bb63686`](https://github.com/inspect-js/is-regex/commit/bb63686a9d0fc586d121549cf484da95edec3b0a)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config@`, `replace`, `semver`, `tape` [`ddf3670`](https://github.com/inspect-js/is-regex/commit/ddf36705e5f7bd29832721e4a23abf06195032c6)
+- [Dev Deps] update `tape`, `nsp`, `eslint`, `@ljharb/eslint-config` [`e7b5a62`](https://github.com/inspect-js/is-regex/commit/e7b5a626eef3b9648c7d52d4620ce2e2a98a9ab8)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `covert`, `tape` [`c803db5`](https://github.com/inspect-js/is-regex/commit/c803db5cd94cf9e0a559617adbc1e4c9d22007ff)
+- [Tests] switch from `nsp` to `npm audit` [`b7239be`](https://github.com/inspect-js/is-regex/commit/b7239be9da263a0f7066f79d087eaf700a9613e9)
+- [Dev Deps] update `eslint`, `nsp`, `semver`, `tape` [`347ee6c`](https://github.com/inspect-js/is-regex/commit/347ee6c67ba0f56b03f21a5abe743658f6515963)
+- Only apps should have lockfiles. [`3866575`](https://github.com/inspect-js/is-regex/commit/38665755ecf028061f15816059e26023890a0dc7)
+- [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops [`d099a39`](https://github.com/inspect-js/is-regex/commit/d099a3943eb7e156a3e64fb8b74e11d7c83a4bec)
+- [meta] add `funding` field [`741aecd`](https://github.com/inspect-js/is-regex/commit/741aecd92cd49868b3606c8cc99ce299e5f3c7d5)
+- [Tests] use `eclint` instead of `editorconfig-tools` [`bc6aa75`](https://github.com/inspect-js/is-regex/commit/bc6aa7539e506788709b96f7bf3d7549850a81c3)
+- [Tests] on `node` `v10.1` [`262226f`](https://github.com/inspect-js/is-regex/commit/262226f08fa34dff9a8dffd16daabb3dc6e262eb)
+- [Dev Deps] update `eslint` [`31fd719`](https://github.com/inspect-js/is-regex/commit/31fd719dd59a6111ca710cdb0d19a8adadf9b8c6)
+- [Deps] update `has` [`e9e25a3`](https://github.com/inspect-js/is-regex/commit/e9e25a3de7e89faaa6aadf5010477074140e8218)
+- [Dev Deps] update `replace` [`aeeb968`](https://github.com/inspect-js/is-regex/commit/aeeb968bf5a4fc07f0fa6905f2c699fc563b6c32)
+- [Tests] set audit level [`2a6290e`](https://github.com/inspect-js/is-regex/commit/2a6290e78b58bf14b734d7998fe53b4a84db5e44)
+- [Tests] remove `nsp` [`fc74c2b`](https://github.com/inspect-js/is-regex/commit/fc74c2bb6970a7f3280abe6eff3b492d77d89c9f)
+
+## [v1.0.4](https://github.com/inspect-js/is-regex/compare/v1.0.3...v1.0.4) - 2017-02-18
+
+### Fixed
+
+- [Fix] ensure that `lastIndex` is not mutated [`#3`](https://github.com/inspect-js/is-regex/issues/3)
+
+### Commits
+
+- Update `eslint`, `tape`, `semver`; use my personal shared `eslint` config [`c4a41c3`](https://github.com/inspect-js/is-regex/commit/c4a41c3a8203a3919b01cd0d1b577daadf30a452)
+- [Tests] on all node minors; improve test matrix [`58d7508`](https://github.com/inspect-js/is-regex/commit/58d7508a36eb92bd76717486b9e78bde502ffe3e)
+- [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`, `semver` [`7290076`](https://github.com/inspect-js/is-regex/commit/729007606e9ed162953d1f5812c37eb06c554ec2)
+- Update `covert`, `jscs`, `eslint`, `semver` [`dabc729`](https://github.com/inspect-js/is-regex/commit/dabc729cfc4458264c6f7642004d41dd5c214bfd)
+- Update `eslint` [`a946b05`](https://github.com/inspect-js/is-regex/commit/a946b051159396b4311c564880f96e3d00e8b8e2)
+- Update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`1744dde`](https://github.com/inspect-js/is-regex/commit/1744dde77526841f216fa2c1c866c5a82b1638c0)
+- [Refactor] when try/catch is needed, bail early if the value lacks an own `lastIndex` data property. [`288ad93`](https://github.com/inspect-js/is-regex/commit/288ad93dbfed9f6828de20de67105ee6d6504425)
+- Update `editorconfig-tools`, `eslint`, `semver`, `replace` [`4d895c6`](https://github.com/inspect-js/is-regex/commit/4d895c68a0cdbb5803185928963c15147aad0404)
+- Update `eslint`, `tape`, `semver` [`f387f03`](https://github.com/inspect-js/is-regex/commit/f387f03b260b56372bfca301d4e79c4067633854)
+- All grade A-supported `node`/`iojs` versions now ship with an `npm` that understands `^`. [`55e480f`](https://github.com/inspect-js/is-regex/commit/55e480f407cafb6c21a6c32aef04ccaa3ba4216c)
+- [Dev Deps] update `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`, `semver` [`89d9528`](https://github.com/inspect-js/is-regex/commit/89d95285b364913ebcd8ac7e0872570fe009a5d3)
+- [Dev Deps] update `jscs` [`eb222a8`](https://github.com/inspect-js/is-regex/commit/eb222a8435e59909354f3700fd4880e4ce1cb13e)
+- [Tests] up to `io.js` `v3.3`, `node` `v4.1` [`c65429c`](https://github.com/inspect-js/is-regex/commit/c65429cea0366508c10ad2ab773af7b83a34fc81)
+- Update `nsp`, `eslint` [`c60fbd8`](https://github.com/inspect-js/is-regex/commit/c60fbd8680f7fb3508ec3c5be8ebb788672516c8)
+- Update `eslint`, `semver` [`6a62116`](https://github.com/inspect-js/is-regex/commit/6a621168c63616bf004ca8b1f885b4eb8a58a3e5)
+- [Tests] on `node` `v7.5`, `v4.7` [`e764651`](https://github.com/inspect-js/is-regex/commit/e764651336f5da5e239e9fe8869f3a3201c19d2b)
+- Test up to `io.js` `v2.1` [`3bf326a`](https://github.com/inspect-js/is-regex/commit/3bf326a9bcd530fd16c9fc806e249a68e25ab7e3)
+- Test on the latest `io.js` versions. [`693d047`](https://github.com/inspect-js/is-regex/commit/693d0477631c5d7671f6c99eca5594ffffa75771)
+- [Refactor] use an early return instead of a ternary. [`31eaca2`](https://github.com/inspect-js/is-regex/commit/31eaca28b7d0aaac0599fe7a569b93b842f8ab16)
+- Test on `io.js` `v2.2` [`c18c55a`](https://github.com/inspect-js/is-regex/commit/c18c55aee6358d70531f935e98851e42b698d93c)
+- Run `travis-ci` tests on `iojs` and `node` v0.12; speed up builds; allow 0.8 failures. [`a1c237d`](https://github.com/inspect-js/is-regex/commit/a1c237d35f880fe0bcbc9275254611a6a2300aaf)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`aa3ea0f`](https://github.com/inspect-js/is-regex/commit/aa3ea0f148af31d75f7ef8a800412729d82def04)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`d97831d`](https://github.com/inspect-js/is-regex/commit/d97831d0e2ccd3d00d1f7354b7f81e2575f90953)
+- [Dev Deps] Update `tape`, `eslint` [`95e6def`](https://github.com/inspect-js/is-regex/commit/95e6defe3178c45dc9df16e474e558979d5f5c05)
+- Update `eslint`, `nsp` [`3844c93`](https://github.com/inspect-js/is-regex/commit/3844c935cfe7c52fae0dc74d27e884c417cb4616)
+- Update `tape`, `jscs` [`0d6dac8`](https://github.com/inspect-js/is-regex/commit/0d6dac818ed251910171965932f021291919e770)
+- Fix tests for faked @@toStringTag [`2ebef9f`](https://github.com/inspect-js/is-regex/commit/2ebef9f0759843e9a063de7a512b46e3e7daea7e)
+- Test up to `io.js` `v3.0` [`ec1d2d4`](https://github.com/inspect-js/is-regex/commit/ec1d2d44481fa0fa11448527da8030c99fe47a12)
+- [Refactor] bail earlier when the value is falsy. [`a9e333e`](https://github.com/inspect-js/is-regex/commit/a9e333e2ac8912ca05b7e31d30e4eea683c0da4b)
+- [Dev Deps] update `tape` [`8cdcaae`](https://github.com/inspect-js/is-regex/commit/8cdcaae07be8c790cdb99849e6076ea7702a4c84)
+- Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG. [`281c4ef`](https://github.com/inspect-js/is-regex/commit/281c4efeb71c86dd380e741bcaee3f7dbf956151)
+- Test on `io.js` `v2.4` [`4d54c68`](https://github.com/inspect-js/is-regex/commit/4d54c68a81b5332a3b76259d8aa8f514be5efd13)
+- Test on `io.js` `v2.3` [`23170f5`](https://github.com/inspect-js/is-regex/commit/23170f5cae632d0377de73bd2febc53db8aebbc9)
+- Test on `iojs-v1.6` [`4487ad0`](https://github.com/inspect-js/is-regex/commit/4487ad0194a5684223bfa2690da4e0a441f7132a)
+
+## [v1.0.3](https://github.com/inspect-js/is-regex/compare/v1.0.2...v1.0.3) - 2015-01-29
+
+### Commits
+
+- Update npm run scripts. [`dc528dd`](https://github.com/inspect-js/is-regex/commit/dc528dd25e775089bc0a3f5a8f7ae7ffc4cdf52a)
+- Add toStringTag tests. [`f48a83a`](https://github.com/inspect-js/is-regex/commit/f48a83a78720b78ab60ca586c16f6f3dbcfec825)
+- If @@toStringTag is not present, use the old-school Object#toString test. [`50b0ffd`](https://github.com/inspect-js/is-regex/commit/50b0ffd9c7fdbd54aee8cde1b07e680ae84f6a0d)
+
+## [v1.0.2](https://github.com/inspect-js/is-regex/compare/v1.0.1...v1.0.2) - 2015-01-29
+
+### Commits
+
+- `make release` [`a1de7ec`](https://github.com/inspect-js/is-regex/commit/a1de7eca4cecc8015fd27804669f8fc61bd16a68)
+- Improve optimization by separating the try/catch, and bailing out early when not typeof "object". [`5ab7632`](https://github.com/inspect-js/is-regex/commit/5ab76322a348487fa8b16761e83f6824c3c27d11)
+
+## [v1.0.1](https://github.com/inspect-js/is-regex/compare/v1.0.0...v1.0.1) - 2015-01-28
+
+### Commits
+
+- Using my standard jscs.json file [`1f1733a`](https://github.com/inspect-js/is-regex/commit/1f1733ac8433cdcceb25356f86b74136a4477cb9)
+- Adding `npm run lint` [`51ea70f`](https://github.com/inspect-js/is-regex/commit/51ea70fa7e461d022f611c195f343ea8d0333d71)
+- Use RegExp#exec to test if something is a regex, which works even with ES6 @@toStringTag. [`042c8c7`](https://github.com/inspect-js/is-regex/commit/042c8c734faade9015932b61f1e8ea4f3a93b1b3)
+- Adding license and downloads badges [`366d619`](https://github.com/inspect-js/is-regex/commit/366d61965d3a4119126e78e09b2166bbcddd0c5a)
+- Use SVG badges instead of PNG [`6a32e4f`](https://github.com/inspect-js/is-regex/commit/6a32e4fc87d7d3a3787b800dd033c9293aead6df)
+- Update `tape`, `jscs` [`f1b9462`](https://github.com/inspect-js/is-regex/commit/f1b9462f86d1b69de07176e7f277f668757ba964)
+- Update `jscs` [`1bff23f`](https://github.com/inspect-js/is-regex/commit/1bff23ff0fe88c8263e8bf04cf99e290af96d5b0)
+- Update `tape`, `jscs` [`c22ea2e`](https://github.com/inspect-js/is-regex/commit/c22ea2e7967f45618deed01ff5ea483f918be216)
+- Update `tape`, `jscs` [`b0479db`](https://github.com/inspect-js/is-regex/commit/b0479db99a1b1b872d1618fb0a71f0c74a78b29b)
+- Use consistent quotes [`1a6e347`](https://github.com/inspect-js/is-regex/commit/1a6e34730d9270f3f20519139faa4c4e6ec2e1f5)
+- Make travis builds faster. [`090a4ea`](https://github.com/inspect-js/is-regex/commit/090a4ea7c5fa709d108d596e3bc304e6ce973dec)
+- Update `tape` [`7d76129`](https://github.com/inspect-js/is-regex/commit/7d7612928bdd43230fbd835db71797249ca24f35)
+- Lock covert to v1.0.0. [`9a90b03`](https://github.com/inspect-js/is-regex/commit/9a90b03fb390e66f874223a34c58ba2bb109edd3)
+- Updating tape [`bfbc7f5`](https://github.com/inspect-js/is-regex/commit/bfbc7f593a007acd0411152bbb55f724dc4ca935)
+- Updating jscs [`13ad511`](https://github.com/inspect-js/is-regex/commit/13ad511d80cd67300c2c0c5387fc4b3b423e2768)
+- Updating jscs [`cda1945`](https://github.com/inspect-js/is-regex/commit/cda1945d603dfe99e24d5a909a931d366451bc4d)
+- Updating jscs [`de96c99`](https://github.com/inspect-js/is-regex/commit/de96c99d4bf5787df671de6df9138b6547a6545b)
+- Running linter as part of tests [`2cb6567`](https://github.com/inspect-js/is-regex/commit/2cb656733b1ed0af14ad11fb584006d22de0c69d)
+- Updating covert [`a56ae74`](https://github.com/inspect-js/is-regex/commit/a56ae74ec8d5f0473295a8b10519a18580f16624)
+- Updating tape [`ffe47f7`](https://github.com/inspect-js/is-regex/commit/ffe47f7fe9cf6d16896b4bdc286bd1d0805d5c49)
+
+## [v1.0.0](https://github.com/inspect-js/is-regex/compare/v0.0.0...v1.0.0) - 2014-05-19
+
+### Commits
+
+- Make sure old and unstable nodes don't break Travis [`05da747`](https://github.com/inspect-js/is-regex/commit/05da7478f960dc131ec3ad864e27e8c6b7d74a80)
+- toString is a reserved var name in old Opera [`885c48c`](https://github.com/inspect-js/is-regex/commit/885c48c120f921a55f1842b0607d3e7875379821)
+- Updating deps [`2ca0e79`](https://github.com/inspect-js/is-regex/commit/2ca0e79a2443ca34d85e8b2ea2e26f55855b74a7)
+- Updating tape. [`9678435`](https://github.com/inspect-js/is-regex/commit/96784355611deb0c23b9064be774216d76e3e457)
+- Updating covert [`c3bb898`](https://github.com/inspect-js/is-regex/commit/c3bb8985a422e3e0c81f9c43899b6c19a72c755f)
+- Updating tape [`7811708`](https://github.com/inspect-js/is-regex/commit/78117089688258b8f939b397b37897b5b3e30f74)
+- Testing on node 0.6 again [`dec36ae`](https://github.com/inspect-js/is-regex/commit/dec36ae58a39a3f80e832b702c3e19406363c160)
+- Run code coverage as part of tests [`e6f4ebe`](https://github.com/inspect-js/is-regex/commit/e6f4ebec26894543747603f2cb360e839f2ca290)
+
+## v0.0.0 - 2014-01-15
+
+### Commits
+
+- package.json [`aa60d43`](https://github.com/inspect-js/is-regex/commit/aa60d43d2c8adb9fdd47f5898e5e1e570bd238d8)
+- read me [`861e944`](https://github.com/inspect-js/is-regex/commit/861e944de88e84010eaa662ea9ea9f17c90cff8c)
+- Initial commit [`d0cdd71`](https://github.com/inspect-js/is-regex/commit/d0cdd71a637d8490b7ee3eaaf75c7e31d0f9242f)
+- Tests. [`b533f74`](https://github.com/inspect-js/is-regex/commit/b533f741a88dff002790fb7af054b2a74e72d4da)
+- Implementation. [`3c9a8c0`](https://github.com/inspect-js/is-regex/commit/3c9a8c06994003cdfffeb3620f251f4c4cae7755)
+- Travis CI [`742c440`](https://github.com/inspect-js/is-regex/commit/742c4407015f9108875fd108fde137f5245e9e7a)
diff --git a/tools/ui/node_modules/is-regex/LICENSE b/tools/ui/node_modules/is-regex/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..47b7b5078fce38783c58381828d9a7f762db7866
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jordan Harband
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/ui/node_modules/is-regex/README.md b/tools/ui/node_modules/is-regex/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d61332bd290fe50c87c466440e9aa170cb1c8dcb
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/README.md
@@ -0,0 +1,52 @@
+# is-regex [![Version Badge][2]][1]
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![dependency status][5]][6]
+[![dev dependency status][7]][8]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][11]][1]
+
+Is this value a JS regex?
+This module works cross-realm/iframe, and despite ES6 @@toStringTag.
+
+## Example
+
+```js
+var isRegex = require('is-regex');
+var assert = require('assert');
+
+assert.notOk(isRegex(undefined));
+assert.notOk(isRegex(null));
+assert.notOk(isRegex(false));
+assert.notOk(isRegex(true));
+assert.notOk(isRegex(42));
+assert.notOk(isRegex('foo'));
+assert.notOk(isRegex(function () {}));
+assert.notOk(isRegex([]));
+assert.notOk(isRegex({}));
+
+assert.ok(isRegex(/a/g));
+assert.ok(isRegex(new RegExp('a', 'g')));
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+[1]: https://npmjs.org/package/is-regex
+[2]: https://versionbadg.es/inspect-js/is-regex.svg
+[5]: https://david-dm.org/inspect-js/is-regex.svg
+[6]: https://david-dm.org/inspect-js/is-regex
+[7]: https://david-dm.org/inspect-js/is-regex/dev-status.svg
+[8]: https://david-dm.org/inspect-js/is-regex#info=devDependencies
+[11]: https://nodei.co/npm/is-regex.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/is-regex.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/is-regex.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=is-regex
+[codecov-image]: https://codecov.io/gh/inspect-js/is-regex/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/inspect-js/is-regex/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/is-regex
+[actions-url]: https://github.com/inspect-js/is-regex/actions
diff --git a/tools/ui/node_modules/is-regex/index.d.ts b/tools/ui/node_modules/is-regex/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..bc63cf6559595bb9558d303e0d1f3d7696e8b9e8
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/index.d.ts
@@ -0,0 +1,3 @@
+declare function isRegex(value: unknown): value is RegExp;
+
+export = isRegex;
diff --git a/tools/ui/node_modules/is-regex/index.js b/tools/ui/node_modules/is-regex/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4c8cede9dd2e15f1aada64efd96ecf776175b32
--- /dev/null
+++ b/tools/ui/node_modules/is-regex/index.js
@@ -0,0 +1,69 @@
+'use strict';
+
+var callBound = require('call-bound');
+var hasToStringTag = require('has-tostringtag/shams')();
+var hasOwn = require('hasown');
+var gOPD = require('gopd');
+
+/** @type {import('.')} */
+var fn;
+
+if (hasToStringTag) {
+ /** @type {(receiver: ThisParameterType
+ 
+