var pyscript = (function (exports) { 'use strict'; var parser$2 = /* * Generated by PEG.js 0.10.0. * * http://pegjs.org/ */ (function() { function peg$subclass(child, parent) { function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); } function peg$SyntaxError(message, expected, found, location) { this.message = message; this.expected = expected; this.found = found; this.location = location; this.name = "SyntaxError"; if (typeof Error.captureStackTrace === "function") { Error.captureStackTrace(this, peg$SyntaxError); } } peg$subclass(peg$SyntaxError, Error); peg$SyntaxError.buildMessage = function(expected, found) { var DESCRIBE_EXPECTATION_FNS = { literal: function(expectation) { return "\"" + literalEscape(expectation.text) + "\""; }, "class": function(expectation) { var escapedParts = "", i; for (i = 0; i < expectation.parts.length; i++) { escapedParts += expectation.parts[i] instanceof Array ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) : classEscape(expectation.parts[i]); } return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]"; }, any: function(expectation) { return "any character"; }, end: function(expectation) { return "end of input"; }, other: function(expectation) { return expectation.description; } }; function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); } function literalEscape(s) { return s .replace(/\\/g, '\\\\') .replace(/"/g, '\\"') .replace(/\0/g, '\\0') .replace(/\t/g, '\\t') .replace(/\n/g, '\\n') .replace(/\r/g, '\\r') .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); } function classEscape(s) { return s .replace(/\\/g, '\\\\') .replace(/\]/g, '\\]') .replace(/\^/g, '\\^') .replace(/-/g, '\\-') .replace(/\0/g, '\\0') .replace(/\t/g, '\\t') .replace(/\n/g, '\\n') .replace(/\r/g, '\\r') .replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); }) .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); }); } function describeExpectation(expectation) { return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation); } function describeExpected(expected) { var descriptions = new Array(expected.length), i, j; for (i = 0; i < expected.length; i++) { descriptions[i] = describeExpectation(expected[i]); } descriptions.sort(); if (descriptions.length > 0) { for (i = 1, j = 1; i < descriptions.length; i++) { if (descriptions[i - 1] !== descriptions[i]) { descriptions[j] = descriptions[i]; j++; } } descriptions.length = j; } switch (descriptions.length) { case 1: return descriptions[0]; case 2: return descriptions[0] + " or " + descriptions[1]; default: return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1]; } } function describeFound(found) { return found ? "\"" + literalEscape(found) + "\"" : "end of input"; } return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found."; }; function peg$parse(input, options) { options = options !== void 0 ? options : {}; var peg$FAILED = {}, peg$startRuleFunctions = { Expressions: peg$parseExpressions }, peg$startRuleFunction = peg$parseExpressions, peg$c0 = function() { return g_root; }, peg$c1 = function(path) { g_context = findContext(g_root, true, path); }, peg$c2 = function(path) { g_context = findContext(g_root, false, path); }, peg$c3 = function(keyValue) { checkTableKey(g_context.table, keyValue[0]); g_context.table[keyValue[0]] = keyValue[1]; }, peg$c4 = peg$otherExpectation("Newline"), peg$c5 = "\n", peg$c6 = peg$literalExpectation("\n", false), peg$c7 = "\r\n", peg$c8 = peg$literalExpectation("\r\n", false), peg$c9 = peg$otherExpectation("Whitespace"), peg$c10 = /^[ \t]/, peg$c11 = peg$classExpectation([" ", "\t"], false, false), peg$c12 = peg$otherExpectation("Comment"), peg$c13 = "#", peg$c14 = peg$literalExpectation("#", false), peg$c15 = peg$anyExpectation(), peg$c16 = "=", peg$c17 = peg$literalExpectation("=", false), peg$c18 = function(key, value) { return [key, value.value]; }, peg$c19 = function() { return text(); }, peg$c20 = peg$otherExpectation("[a-z], [A-Z], [0-9], \"-\", \"_\""), peg$c21 = /^[a-zA-Z0-9\-_]/, peg$c22 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "-", "_"], false, false), peg$c23 = function(chars) { return chars.join(''); }, peg$c24 = peg$otherExpectation("DoubleQuote"), peg$c25 = "\"", peg$c26 = peg$literalExpectation("\"", false), peg$c27 = peg$otherExpectation("SingleQuote"), peg$c28 = "'", peg$c29 = peg$literalExpectation("'", false), peg$c30 = peg$otherExpectation("ThreeDoubleQuotes"), peg$c31 = "\"\"\"", peg$c32 = peg$literalExpectation("\"\"\"", false), peg$c33 = peg$otherExpectation("ThreeSingleQuotes"), peg$c34 = "'''", peg$c35 = peg$literalExpectation("'''", false), peg$c36 = function(chars) { return { type: 'String', value: chars.join('') }; }, peg$c37 = peg$otherExpectation("NormalCharacter"), peg$c38 = /^[^\0-\x1F"\\]/, peg$c39 = peg$classExpectation([["\0", "\x1F"], "\"", "\\"], true, false), peg$c40 = "u", peg$c41 = peg$literalExpectation("u", false), peg$c42 = "U", peg$c43 = peg$literalExpectation("U", false), peg$c44 = function() { var s = text(); if (s.length <= 2) { return unescape(s[1]); } return fromCodePoint(parseInt(s.substr(2), 16)); }, peg$c45 = peg$otherExpectation("\"b\", \"f\", \"n\", \"r\", \"t\""), peg$c46 = /^[bfnrt]/, peg$c47 = peg$classExpectation(["b", "f", "n", "r", "t"], false, false), peg$c48 = peg$otherExpectation("Backslash"), peg$c49 = "\\", peg$c50 = peg$literalExpectation("\\", false), peg$c51 = peg$otherExpectation("FourHexadecimalDigits"), peg$c52 = peg$otherExpectation("EightHexadecimalDigits"), peg$c53 = /^[0-9A-Fa-f]/, peg$c54 = peg$classExpectation([["0", "9"], ["A", "F"], ["a", "f"]], false, false), peg$c55 = function() { var s = text(); return { type: 'String', value: s.substr(1, s.length - 2) }; }, peg$c56 = /^[^\0-\x08\n-\x1F']/, peg$c57 = peg$classExpectation([["\0", "\b"], ["\n", "\x1F"], "'"], true, false), peg$c58 = function(chars) { return { type: 'String', value: chars.join('').replace(/\\\r?\n(?:\r?\n|[ \t])*/g, '') }; }, peg$c59 = /^[^\0-\x1F\\]/, peg$c60 = peg$classExpectation([["\0", "\x1F"], "\\"], true, false), peg$c61 = peg$otherExpectation("AnyCharacter"), peg$c62 = /^[^\0-\x08\n-\x1F]/, peg$c63 = peg$classExpectation([["\0", "\b"], ["\n", "\x1F"]], true, false), peg$c64 = "true", peg$c65 = peg$literalExpectation("true", false), peg$c66 = function() { return { type: 'Boolean', value: true }; }, peg$c67 = "false", peg$c68 = peg$literalExpectation("false", false), peg$c69 = function() { return { type: 'Boolean', value: false }; }, peg$c70 = function() { // A double-precision 64-bit floating-point number in IEEE 754 standard. var s = text(); var number = parseFloat(s.replace(/_/g, '')); if (!isFiniteNumber(number)) { error(s + 'is not a 64-bit floating-point number.'); } return { type: 'Float', value: number }; }, peg$c71 = ".", peg$c72 = peg$literalExpectation(".", false), peg$c73 = "_", peg$c74 = peg$literalExpectation("_", false), peg$c75 = "e", peg$c76 = peg$literalExpectation("e", false), peg$c77 = "E", peg$c78 = peg$literalExpectation("E", false), peg$c79 = function() { // Be careful of JavaScript limits: // 1) Number.MAX_SAFE_INTEGER = 9007199254740991 // 2) Number.MIN_SAFE_INTEGER = -9007199254740991 var s = text(); var number = s.replace(/_/g, ''); // Check if it is a 64-bit signed integer. var invalid = false; if (number[0] === '-') { var minInt = '-9223372036854775808'; if (number.length > minInt.length || (number.length === minInt.length && number > minInt)) { invalid = true; } } else { if (number[0] === '+') { number = number.substr(1); } var maxInt = '9223372036854775807'; if (number.length > maxInt.length || (number.length === maxInt.length && number > maxInt)) { invalid = true; } } if (invalid) { error(s + ' is not a 64-bit signed integer.'); } number = parseInt(number, 10); if (!isFiniteNumber(number)) { error(s + ' is not a 64-bit signed integer.'); } return { type: 'Integer', value: number }; }, peg$c80 = "+", peg$c81 = peg$literalExpectation("+", false), peg$c82 = "-", peg$c83 = peg$literalExpectation("-", false), peg$c84 = /^[1-9]/, peg$c85 = peg$classExpectation([["1", "9"]], false, false), peg$c86 = /^[0-9]/, peg$c87 = peg$classExpectation([["0", "9"]], false, false), peg$c88 = "T", peg$c89 = peg$literalExpectation("T", false), peg$c90 = function() { var s = text(); var date = new Date(s); if (!isFiniteNumber(date.getTime())) { error('Date-time ' + s + ' is invalid. It does not conform to RFC 3339 or this is a browser-specific problem.'); } return { type: 'DateTime', value: date }; }, peg$c91 = peg$otherExpectation("FullDate (YYYY-mm-dd)"), peg$c92 = ":", peg$c93 = peg$literalExpectation(":", false), peg$c94 = peg$otherExpectation("Hour (HH)"), peg$c95 = peg$otherExpectation("Minute (MM)"), peg$c96 = peg$otherExpectation("Second (SS)"), peg$c97 = peg$otherExpectation("TimeOffset (Z or +/-HH:MM)"), peg$c98 = "Z", peg$c99 = peg$literalExpectation("Z", false), peg$c100 = "[", peg$c101 = peg$literalExpectation("[", false), peg$c102 = ",", peg$c103 = peg$literalExpectation(",", false), peg$c104 = "]", peg$c105 = peg$literalExpectation("]", false), peg$c106 = function(values) { var o = { type: 'Array', value: values ? values[0] : [] }; for (var i = 0, arr = o.value, l = arr.length; i < l; i++) { arr[i] = arr[i].value; } return o; }, peg$c107 = function(value, opt) { var array = [value]; if (opt) { var type = value.type; for (var i = 0, arr = opt[3], l = arr.length; i < l; i++) { if (type !== arr[i].type) { error(stringify(arr[i].value) + ' should be of type "' + type + '".'); } array.push(arr[i]); } } return array; }, peg$c108 = "{", peg$c109 = peg$literalExpectation("{", false), peg$c110 = "}", peg$c111 = peg$literalExpectation("}", false), peg$c112 = function(opt) { var table = {}; if (opt) { table[opt[0][0]] = opt[0][1]; for (var i = 0, arr = opt[1], l = arr.length; i < l; i++) { var kv = arr[i][3]; checkTableKey(table, kv[0]); table[kv[0]] = kv[1]; } } return { type: 'InlineTable', value: table }; }, peg$c113 = function(path) { return path; }, peg$c114 = function(key, arr) { var path = [key]; for (var i = 0, l = arr.length; i < l; i++) { path.push(arr[i][3]); } return path; }, peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result; if ("startRule" in options) { if (!(options.startRule in peg$startRuleFunctions)) { throw new Error("Can't start parsing from rule \"" + options.startRule + "\"."); } peg$startRuleFunction = peg$startRuleFunctions[options.startRule]; } function text() { return input.substring(peg$savedPos, peg$currPos); } function error(message, location) { location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos); throw peg$buildSimpleError(message, location); } function peg$literalExpectation(text, ignoreCase) { return { type: "literal", text: text, ignoreCase: ignoreCase }; } function peg$classExpectation(parts, inverted, ignoreCase) { return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase }; } function peg$anyExpectation() { return { type: "any" }; } function peg$endExpectation() { return { type: "end" }; } function peg$otherExpectation(description) { return { type: "other", description: description }; } function peg$computePosDetails(pos) { var details = peg$posDetailsCache[pos], p; if (details) { return details; } else { p = pos - 1; while (!peg$posDetailsCache[p]) { p--; } details = peg$posDetailsCache[p]; details = { line: details.line, column: details.column }; while (p < pos) { if (input.charCodeAt(p) === 10) { details.line++; details.column = 1; } else { details.column++; } p++; } peg$posDetailsCache[pos] = details; return details; } } function peg$computeLocation(startPos, endPos) { var startPosDetails = peg$computePosDetails(startPos), endPosDetails = peg$computePosDetails(endPos); return { start: { offset: startPos, line: startPosDetails.line, column: startPosDetails.column }, end: { offset: endPos, line: endPosDetails.line, column: endPosDetails.column } }; } function peg$fail(expected) { if (peg$currPos < peg$maxFailPos) { return; } if (peg$currPos > peg$maxFailPos) { peg$maxFailPos = peg$currPos; peg$maxFailExpected = []; } peg$maxFailExpected.push(expected); } function peg$buildSimpleError(message, location) { return new peg$SyntaxError(message, null, null, location); } function peg$buildStructuredError(expected, found, location) { return new peg$SyntaxError( peg$SyntaxError.buildMessage(expected, found), expected, found, location ); } function peg$parseExpressions() { var s0, s1, s2, s3, s4, s5, s6, s7; s0 = peg$currPos; s1 = []; s2 = peg$parseWhitespace(); if (s2 === peg$FAILED) { s2 = peg$parseNewline(); if (s2 === peg$FAILED) { s2 = peg$parseComment(); } } while (s2 !== peg$FAILED) { s1.push(s2); s2 = peg$parseWhitespace(); if (s2 === peg$FAILED) { s2 = peg$parseNewline(); if (s2 === peg$FAILED) { s2 = peg$parseComment(); } } } if (s1 !== peg$FAILED) { s2 = peg$currPos; s3 = peg$parseExpression(); if (s3 !== peg$FAILED) { s4 = []; s5 = peg$parseWhitespace(); if (s5 === peg$FAILED) { s5 = peg$parseComment(); } while (s5 !== peg$FAILED) { s4.push(s5); s5 = peg$parseWhitespace(); if (s5 === peg$FAILED) { s5 = peg$parseComment(); } } if (s4 !== peg$FAILED) { s5 = peg$currPos; s6 = peg$parseNewline(); if (s6 !== peg$FAILED) { s7 = peg$parseExpressions(); if (s7 !== peg$FAILED) { s6 = [s6, s7]; s5 = s6; } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } if (s5 === peg$FAILED) { s5 = null; } if (s5 !== peg$FAILED) { s3 = [s3, s4, s5]; s2 = s3; } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } if (s2 === peg$FAILED) { s2 = null; } if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c0(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseExpression() { var s0, s1; s0 = peg$currPos; s1 = peg$parseTableArrayHeader(); if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c1(s1); } s0 = s1; if (s0 === peg$FAILED) { s0 = peg$currPos; s1 = peg$parseTableHeader(); if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c2(s1); } s0 = s1; if (s0 === peg$FAILED) { s0 = peg$currPos; s1 = peg$parseKeyValue(); if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c3(s1); } s0 = s1; } } return s0; } function peg$parseNewline() { var s0; peg$silentFails++; if (input.charCodeAt(peg$currPos) === 10) { s0 = peg$c5; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c6); } } if (s0 === peg$FAILED) { if (input.substr(peg$currPos, 2) === peg$c7) { s0 = peg$c7; peg$currPos += 2; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c8); } } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c4); } } return s0; } function peg$parseWhitespace() { var s0; peg$silentFails++; if (peg$c10.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c11); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c9); } } return s0; } function peg$parseComment() { var s0, s1, s2, s3, s4, s5; peg$silentFails++; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 35) { s1 = peg$c13; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c14); } } if (s1 !== peg$FAILED) { s2 = []; s3 = peg$currPos; s4 = peg$currPos; peg$silentFails++; s5 = peg$parseNewline(); peg$silentFails--; if (s5 === peg$FAILED) { s4 = void 0; } else { peg$currPos = s4; s4 = peg$FAILED; } if (s4 !== peg$FAILED) { if (input.length > peg$currPos) { s5 = input.charAt(peg$currPos); peg$currPos++; } else { s5 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c15); } } if (s5 !== peg$FAILED) { s4 = [s4, s5]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$currPos; s4 = peg$currPos; peg$silentFails++; s5 = peg$parseNewline(); peg$silentFails--; if (s5 === peg$FAILED) { s4 = void 0; } else { peg$currPos = s4; s4 = peg$FAILED; } if (s4 !== peg$FAILED) { if (input.length > peg$currPos) { s5 = input.charAt(peg$currPos); peg$currPos++; } else { s5 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c15); } } if (s5 !== peg$FAILED) { s4 = [s4, s5]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c12); } } return s0; } function peg$parseKeyValue() { var s0, s1, s2, s3, s4, s5; s0 = peg$currPos; s1 = peg$parseKey(); if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseWhitespace(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseWhitespace(); } if (s2 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 61) { s3 = peg$c16; peg$currPos++; } else { s3 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c17); } } if (s3 !== peg$FAILED) { s4 = []; s5 = peg$parseWhitespace(); while (s5 !== peg$FAILED) { s4.push(s5); s5 = peg$parseWhitespace(); } if (s4 !== peg$FAILED) { s5 = peg$parseValue(); if (s5 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c18(s1, s5); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseKey() { var s0; s0 = peg$parseBareKey(); if (s0 === peg$FAILED) { s0 = peg$parseQuotedKey(); } return s0; } function peg$parseBareKey() { var s0, s1, s2; s0 = peg$currPos; s1 = []; s2 = peg$parseBareKeyCharacter(); if (s2 !== peg$FAILED) { while (s2 !== peg$FAILED) { s1.push(s2); s2 = peg$parseBareKeyCharacter(); } } else { s1 = peg$FAILED; } if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c19(); } s0 = s1; return s0; } function peg$parseBareKeyCharacter() { var s0; peg$silentFails++; if (peg$c21.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c22); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c20); } } return s0; } function peg$parseQuotedKey() { var s0, s1, s2, s3; s0 = peg$currPos; s1 = peg$parseDoubleQuote(); if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseBasicCharacter(); if (s3 !== peg$FAILED) { while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseBasicCharacter(); } } else { s2 = peg$FAILED; } if (s2 !== peg$FAILED) { s3 = peg$parseDoubleQuote(); if (s3 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c23(s2); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseDoubleQuote() { var s0; peg$silentFails++; if (input.charCodeAt(peg$currPos) === 34) { s0 = peg$c25; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c26); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c24); } } return s0; } function peg$parseSingleQuote() { var s0; peg$silentFails++; if (input.charCodeAt(peg$currPos) === 39) { s0 = peg$c28; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c29); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c27); } } return s0; } function peg$parseThreeDoubleQuotes() { var s0; peg$silentFails++; if (input.substr(peg$currPos, 3) === peg$c31) { s0 = peg$c31; peg$currPos += 3; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c32); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c30); } } return s0; } function peg$parseThreeSingleQuotes() { var s0; peg$silentFails++; if (input.substr(peg$currPos, 3) === peg$c34) { s0 = peg$c34; peg$currPos += 3; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c35); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c33); } } return s0; } function peg$parseValue() { var s0; s0 = peg$parseString(); if (s0 === peg$FAILED) { s0 = peg$parseBoolean(); if (s0 === peg$FAILED) { s0 = peg$parseDateTime(); if (s0 === peg$FAILED) { s0 = peg$parseFloat(); if (s0 === peg$FAILED) { s0 = peg$parseInteger(); if (s0 === peg$FAILED) { s0 = peg$parseArray(); if (s0 === peg$FAILED) { s0 = peg$parseInlineTable(); } } } } } } return s0; } function peg$parseString() { var s0; s0 = peg$parseMultilineBasicString(); if (s0 === peg$FAILED) { s0 = peg$parseBasicString(); if (s0 === peg$FAILED) { s0 = peg$parseMultilineLiteralString(); if (s0 === peg$FAILED) { s0 = peg$parseLiteralString(); } } } return s0; } function peg$parseBasicString() { var s0, s1, s2, s3; s0 = peg$currPos; s1 = peg$parseDoubleQuote(); if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseBasicCharacter(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseBasicCharacter(); } if (s2 !== peg$FAILED) { s3 = peg$parseDoubleQuote(); if (s3 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c36(s2); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseBasicCharacter() { var s0; s0 = peg$parseNormalCharacter(); if (s0 === peg$FAILED) { s0 = peg$parseEscapedCharacter(); } return s0; } function peg$parseNormalCharacter() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; s2 = peg$parseNewline(); peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { if (peg$c38.test(input.charAt(peg$currPos))) { s2 = input.charAt(peg$currPos); peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c39); } } if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c19(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c37); } } return s0; } function peg$parseEscapedCharacter() { var s0, s1, s2, s3, s4; s0 = peg$currPos; s1 = peg$parseBackslash(); if (s1 !== peg$FAILED) { s2 = peg$parseControlCharacter(); if (s2 === peg$FAILED) { s2 = peg$parseDoubleQuote(); if (s2 === peg$FAILED) { s2 = peg$parseBackslash(); if (s2 === peg$FAILED) { s2 = peg$currPos; if (input.charCodeAt(peg$currPos) === 117) { s3 = peg$c40; peg$currPos++; } else { s3 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c41); } } if (s3 !== peg$FAILED) { s4 = peg$parseFourHexadecimalDigits(); if (s4 !== peg$FAILED) { s3 = [s3, s4]; s2 = s3; } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } if (s2 === peg$FAILED) { s2 = peg$currPos; if (input.charCodeAt(peg$currPos) === 85) { s3 = peg$c42; peg$currPos++; } else { s3 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c43); } } if (s3 !== peg$FAILED) { s4 = peg$parseEightHexadecimalDigits(); if (s4 !== peg$FAILED) { s3 = [s3, s4]; s2 = s3; } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } } } } } if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c44(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseControlCharacter() { var s0; peg$silentFails++; if (peg$c46.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c47); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c45); } } return s0; } function peg$parseBackslash() { var s0; peg$silentFails++; if (input.charCodeAt(peg$currPos) === 92) { s0 = peg$c49; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c50); } } peg$silentFails--; if (s0 === peg$FAILED) { if (peg$silentFails === 0) { peg$fail(peg$c48); } } return s0; } function peg$parseFourHexadecimalDigits() { var s0, s1, s2, s3, s4; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseHexDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseHexDigit(); if (s2 !== peg$FAILED) { s3 = peg$parseHexDigit(); if (s3 !== peg$FAILED) { s4 = peg$parseHexDigit(); if (s4 !== peg$FAILED) { s1 = [s1, s2, s3, s4]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c51); } } return s0; } function peg$parseEightHexadecimalDigits() { var s0, s1, s2, s3, s4, s5, s6, s7, s8; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseHexDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseHexDigit(); if (s2 !== peg$FAILED) { s3 = peg$parseHexDigit(); if (s3 !== peg$FAILED) { s4 = peg$parseHexDigit(); if (s4 !== peg$FAILED) { s5 = peg$parseHexDigit(); if (s5 !== peg$FAILED) { s6 = peg$parseHexDigit(); if (s6 !== peg$FAILED) { s7 = peg$parseHexDigit(); if (s7 !== peg$FAILED) { s8 = peg$parseHexDigit(); if (s8 !== peg$FAILED) { s1 = [s1, s2, s3, s4, s5, s6, s7, s8]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c52); } } return s0; } function peg$parseHexDigit() { var s0; if (peg$c53.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c54); } } return s0; } function peg$parseLiteralString() { var s0, s1, s2, s3; s0 = peg$currPos; s1 = peg$parseSingleQuote(); if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseLiteralCharacter(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseLiteralCharacter(); } if (s2 !== peg$FAILED) { s3 = peg$parseSingleQuote(); if (s3 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c55(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseLiteralCharacter() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; s2 = peg$parseNewline(); peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { if (peg$c56.test(input.charAt(peg$currPos))) { s2 = input.charAt(peg$currPos); peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c57); } } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c37); } } return s0; } function peg$parseMultilineBasicString() { var s0, s1, s2, s3, s4; s0 = peg$currPos; s1 = peg$parseThreeDoubleQuotes(); if (s1 !== peg$FAILED) { s2 = peg$parseNewline(); if (s2 === peg$FAILED) { s2 = null; } if (s2 !== peg$FAILED) { s3 = []; s4 = peg$parseMultilineBasicText(); while (s4 !== peg$FAILED) { s3.push(s4); s4 = peg$parseMultilineBasicText(); } if (s3 !== peg$FAILED) { s4 = peg$parseThreeDoubleQuotes(); if (s4 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c58(s3); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseMultilineBasicText() { var s0, s1, s2; s0 = peg$parseMultilineBasicCharacter(); if (s0 === peg$FAILED) { s0 = peg$currPos; s1 = peg$parseBackslash(); if (s1 !== peg$FAILED) { s2 = peg$parseNewline(); if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c19(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } if (s0 === peg$FAILED) { s0 = peg$parseNewline(); } } return s0; } function peg$parseMultilineBasicCharacter() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; s2 = peg$parseThreeDoubleQuotes(); peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { s2 = peg$parseMultilineNormalCharacter(); if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c19(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } if (s0 === peg$FAILED) { s0 = peg$parseEscapedCharacter(); } return s0; } function peg$parseMultilineNormalCharacter() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; s2 = peg$parseNewline(); peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { if (peg$c59.test(input.charAt(peg$currPos))) { s2 = input.charAt(peg$currPos); peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c60); } } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c37); } } return s0; } function peg$parseMultilineLiteralString() { var s0, s1, s2, s3, s4; s0 = peg$currPos; s1 = peg$parseThreeSingleQuotes(); if (s1 !== peg$FAILED) { s2 = peg$parseNewline(); if (s2 === peg$FAILED) { s2 = null; } if (s2 !== peg$FAILED) { s3 = []; s4 = peg$parseMultilineLiteralText(); while (s4 !== peg$FAILED) { s3.push(s4); s4 = peg$parseMultilineLiteralText(); } if (s3 !== peg$FAILED) { s4 = peg$parseThreeSingleQuotes(); if (s4 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c36(s3); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseMultilineLiteralText() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; if (input.substr(peg$currPos, 3) === peg$c34) { s2 = peg$c34; peg$currPos += 3; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c35); } } peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { s2 = peg$parseMultilineLiteralCharacter(); if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c19(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } if (s0 === peg$FAILED) { s0 = peg$parseNewline(); } return s0; } function peg$parseMultilineLiteralCharacter() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$currPos; peg$silentFails++; s2 = peg$parseNewline(); peg$silentFails--; if (s2 === peg$FAILED) { s1 = void 0; } else { peg$currPos = s1; s1 = peg$FAILED; } if (s1 !== peg$FAILED) { if (peg$c62.test(input.charAt(peg$currPos))) { s2 = input.charAt(peg$currPos); peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c63); } } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c61); } } return s0; } function peg$parseBoolean() { var s0, s1; s0 = peg$currPos; if (input.substr(peg$currPos, 4) === peg$c64) { s1 = peg$c64; peg$currPos += 4; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c65); } } if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c66(); } s0 = s1; if (s0 === peg$FAILED) { s0 = peg$currPos; if (input.substr(peg$currPos, 5) === peg$c67) { s1 = peg$c67; peg$currPos += 5; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c68); } } if (s1 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c69(); } s0 = s1; } return s0; } function peg$parseFloat() { var s0, s1, s2, s3, s4; s0 = peg$currPos; s1 = peg$parseInteger(); if (s1 !== peg$FAILED) { s2 = peg$currPos; s3 = peg$parseFraction(); if (s3 !== peg$FAILED) { s4 = peg$parseExponent(); if (s4 === peg$FAILED) { s4 = null; } if (s4 !== peg$FAILED) { s3 = [s3, s4]; s2 = s3; } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } if (s2 === peg$FAILED) { s2 = peg$parseExponent(); } if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c70(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseFraction() { var s0, s1, s2, s3, s4, s5, s6; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 46) { s1 = peg$c71; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c72); } } if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s3 = []; s4 = peg$currPos; if (input.charCodeAt(peg$currPos) === 95) { s5 = peg$c73; peg$currPos++; } else { s5 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c74); } } if (s5 === peg$FAILED) { s5 = null; } if (s5 !== peg$FAILED) { s6 = peg$parseDigit(); if (s6 !== peg$FAILED) { s5 = [s5, s6]; s4 = s5; } else { peg$currPos = s4; s4 = peg$FAILED; } } else { peg$currPos = s4; s4 = peg$FAILED; } while (s4 !== peg$FAILED) { s3.push(s4); s4 = peg$currPos; if (input.charCodeAt(peg$currPos) === 95) { s5 = peg$c73; peg$currPos++; } else { s5 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c74); } } if (s5 === peg$FAILED) { s5 = null; } if (s5 !== peg$FAILED) { s6 = peg$parseDigit(); if (s6 !== peg$FAILED) { s5 = [s5, s6]; s4 = s5; } else { peg$currPos = s4; s4 = peg$FAILED; } } else { peg$currPos = s4; s4 = peg$FAILED; } } if (s3 !== peg$FAILED) { s1 = [s1, s2, s3]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseExponent() { var s0, s1, s2; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 101) { s1 = peg$c75; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c76); } } if (s1 === peg$FAILED) { if (input.charCodeAt(peg$currPos) === 69) { s1 = peg$c77; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c78); } } } if (s1 !== peg$FAILED) { s2 = peg$parseInteger(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseInteger() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$parseSign(); if (s1 === peg$FAILED) { s1 = null; } if (s1 !== peg$FAILED) { s2 = peg$parseIntDigits(); if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c79(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseSign() { var s0; if (input.charCodeAt(peg$currPos) === 43) { s0 = peg$c80; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c81); } } if (s0 === peg$FAILED) { if (input.charCodeAt(peg$currPos) === 45) { s0 = peg$c82; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c83); } } } return s0; } function peg$parseIntDigits() { var s0, s1, s2, s3, s4, s5; s0 = peg$currPos; s1 = peg$parseDigit_1to9(); if (s1 !== peg$FAILED) { s2 = []; s3 = peg$currPos; if (input.charCodeAt(peg$currPos) === 95) { s4 = peg$c73; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c74); } } if (s4 === peg$FAILED) { s4 = null; } if (s4 !== peg$FAILED) { s5 = peg$parseDigit(); if (s5 !== peg$FAILED) { s4 = [s4, s5]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } if (s3 !== peg$FAILED) { while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$currPos; if (input.charCodeAt(peg$currPos) === 95) { s4 = peg$c73; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c74); } } if (s4 === peg$FAILED) { s4 = null; } if (s4 !== peg$FAILED) { s5 = peg$parseDigit(); if (s5 !== peg$FAILED) { s4 = [s4, s5]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } } } else { s2 = peg$FAILED; } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } if (s0 === peg$FAILED) { s0 = peg$parseDigit(); } return s0; } function peg$parseDigit_1to9() { var s0; if (peg$c84.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c85); } } return s0; } function peg$parseDigit() { var s0; if (peg$c86.test(input.charAt(peg$currPos))) { s0 = input.charAt(peg$currPos); peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c87); } } return s0; } function peg$parseDateTime() { var s0, s1, s2, s3; s0 = peg$currPos; s1 = peg$parseFullDate(); if (s1 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 84) { s2 = peg$c88; peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c89); } } if (s2 !== peg$FAILED) { s3 = peg$parseFullTime(); if (s3 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c90(); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseFullDate() { var s0, s1, s2, s3, s4, s5; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseYear(); if (s1 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 45) { s2 = peg$c82; peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c83); } } if (s2 !== peg$FAILED) { s3 = peg$parseMonth(); if (s3 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 45) { s4 = peg$c82; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c83); } } if (s4 !== peg$FAILED) { s5 = peg$parseMDay(); if (s5 !== peg$FAILED) { s1 = [s1, s2, s3, s4, s5]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c91); } } return s0; } function peg$parseYear() { var s0, s1, s2, s3, s4; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s3 = peg$parseDigit(); if (s3 !== peg$FAILED) { s4 = peg$parseDigit(); if (s4 !== peg$FAILED) { s1 = [s1, s2, s3, s4]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseMonth() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseMDay() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseFullTime() { var s0, s1, s2; s0 = peg$currPos; s1 = peg$parseTime(); if (s1 !== peg$FAILED) { s2 = peg$parseTimeOffset(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseTime() { var s0, s1, s2, s3, s4, s5, s6; s0 = peg$currPos; s1 = peg$parseHour(); if (s1 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 58) { s2 = peg$c92; peg$currPos++; } else { s2 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c93); } } if (s2 !== peg$FAILED) { s3 = peg$parseMinute(); if (s3 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 58) { s4 = peg$c92; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c93); } } if (s4 !== peg$FAILED) { s5 = peg$parseSecond(); if (s5 !== peg$FAILED) { s6 = peg$parseSecondFraction(); if (s6 === peg$FAILED) { s6 = null; } if (s6 !== peg$FAILED) { s1 = [s1, s2, s3, s4, s5, s6]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseHour() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c94); } } return s0; } function peg$parseMinute() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c95); } } return s0; } function peg$parseSecond() { var s0, s1, s2; peg$silentFails++; s0 = peg$currPos; s1 = peg$parseDigit(); if (s1 !== peg$FAILED) { s2 = peg$parseDigit(); if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c96); } } return s0; } function peg$parseSecondFraction() { var s0, s1, s2, s3; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 46) { s1 = peg$c71; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c72); } } if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseDigit(); if (s3 !== peg$FAILED) { while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseDigit(); } } else { s2 = peg$FAILED; } if (s2 !== peg$FAILED) { s1 = [s1, s2]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseTimeOffset() { var s0, s1, s2, s3, s4; peg$silentFails++; if (input.charCodeAt(peg$currPos) === 90) { s0 = peg$c98; peg$currPos++; } else { s0 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c99); } } if (s0 === peg$FAILED) { s0 = peg$currPos; s1 = peg$parseSign(); if (s1 !== peg$FAILED) { s2 = peg$parseHour(); if (s2 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 58) { s3 = peg$c92; peg$currPos++; } else { s3 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c93); } } if (s3 !== peg$FAILED) { s4 = peg$parseMinute(); if (s4 !== peg$FAILED) { s1 = [s1, s2, s3, s4]; s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } peg$silentFails--; if (s0 === peg$FAILED) { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c97); } } return s0; } function peg$parseArray() { var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 91) { s1 = peg$c100; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c101); } } if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseArraySpace(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseArraySpace(); } if (s2 !== peg$FAILED) { s3 = peg$currPos; s4 = peg$parseArrayValue(); if (s4 !== peg$FAILED) { s5 = []; s6 = peg$parseArraySpace(); while (s6 !== peg$FAILED) { s5.push(s6); s6 = peg$parseArraySpace(); } if (s5 !== peg$FAILED) { s6 = peg$currPos; if (input.charCodeAt(peg$currPos) === 44) { s7 = peg$c102; peg$currPos++; } else { s7 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c103); } } if (s7 !== peg$FAILED) { s8 = []; s9 = peg$parseArraySpace(); while (s9 !== peg$FAILED) { s8.push(s9); s9 = peg$parseArraySpace(); } if (s8 !== peg$FAILED) { s7 = [s7, s8]; s6 = s7; } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } if (s6 === peg$FAILED) { s6 = null; } if (s6 !== peg$FAILED) { s4 = [s4, s5, s6]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } if (s3 === peg$FAILED) { s3 = null; } if (s3 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 93) { s4 = peg$c104; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c105); } } if (s4 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c106(s3); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseArrayValue() { var s0, s1, s2, s3, s4, s5, s6; s0 = peg$currPos; s1 = peg$parseValue(); if (s1 !== peg$FAILED) { s2 = peg$currPos; s3 = []; s4 = peg$parseArraySpace(); while (s4 !== peg$FAILED) { s3.push(s4); s4 = peg$parseArraySpace(); } if (s3 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 44) { s4 = peg$c102; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c103); } } if (s4 !== peg$FAILED) { s5 = []; s6 = peg$parseArraySpace(); while (s6 !== peg$FAILED) { s5.push(s6); s6 = peg$parseArraySpace(); } if (s5 !== peg$FAILED) { s6 = peg$parseArrayValue(); if (s6 !== peg$FAILED) { s3 = [s3, s4, s5, s6]; s2 = s3; } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } } else { peg$currPos = s2; s2 = peg$FAILED; } if (s2 === peg$FAILED) { s2 = null; } if (s2 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c107(s1, s2); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseArraySpace() { var s0; s0 = peg$parseWhitespace(); if (s0 === peg$FAILED) { s0 = peg$parseNewline(); if (s0 === peg$FAILED) { s0 = peg$parseComment(); } } return s0; } function peg$parseInlineTable() { var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 123) { s1 = peg$c108; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c109); } } if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseWhitespace(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseWhitespace(); } if (s2 !== peg$FAILED) { s3 = peg$currPos; s4 = peg$parseKeyValue(); if (s4 !== peg$FAILED) { s5 = []; s6 = peg$currPos; s7 = []; s8 = peg$parseWhitespace(); while (s8 !== peg$FAILED) { s7.push(s8); s8 = peg$parseWhitespace(); } if (s7 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 44) { s8 = peg$c102; peg$currPos++; } else { s8 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c103); } } if (s8 !== peg$FAILED) { s9 = []; s10 = peg$parseWhitespace(); while (s10 !== peg$FAILED) { s9.push(s10); s10 = peg$parseWhitespace(); } if (s9 !== peg$FAILED) { s10 = peg$parseKeyValue(); if (s10 !== peg$FAILED) { s7 = [s7, s8, s9, s10]; s6 = s7; } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } while (s6 !== peg$FAILED) { s5.push(s6); s6 = peg$currPos; s7 = []; s8 = peg$parseWhitespace(); while (s8 !== peg$FAILED) { s7.push(s8); s8 = peg$parseWhitespace(); } if (s7 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 44) { s8 = peg$c102; peg$currPos++; } else { s8 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c103); } } if (s8 !== peg$FAILED) { s9 = []; s10 = peg$parseWhitespace(); while (s10 !== peg$FAILED) { s9.push(s10); s10 = peg$parseWhitespace(); } if (s9 !== peg$FAILED) { s10 = peg$parseKeyValue(); if (s10 !== peg$FAILED) { s7 = [s7, s8, s9, s10]; s6 = s7; } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } } else { peg$currPos = s6; s6 = peg$FAILED; } } if (s5 !== peg$FAILED) { s6 = []; s7 = peg$parseWhitespace(); while (s7 !== peg$FAILED) { s6.push(s7); s7 = peg$parseWhitespace(); } if (s6 !== peg$FAILED) { s4 = [s4, s5, s6]; s3 = s4; } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } } else { peg$currPos = s3; s3 = peg$FAILED; } if (s3 === peg$FAILED) { s3 = null; } if (s3 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 125) { s4 = peg$c110; peg$currPos++; } else { s4 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c111); } } if (s4 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c112(s3); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseTableArrayHeader() { var s0, s1, s2, s3; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 91) { s1 = peg$c100; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c101); } } if (s1 !== peg$FAILED) { s2 = peg$parseTableHeader(); if (s2 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 93) { s3 = peg$c104; peg$currPos++; } else { s3 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c105); } } if (s3 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c113(s2); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } function peg$parseTableHeader() { var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9; s0 = peg$currPos; if (input.charCodeAt(peg$currPos) === 91) { s1 = peg$c100; peg$currPos++; } else { s1 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c101); } } if (s1 !== peg$FAILED) { s2 = []; s3 = peg$parseWhitespace(); while (s3 !== peg$FAILED) { s2.push(s3); s3 = peg$parseWhitespace(); } if (s2 !== peg$FAILED) { s3 = peg$parseKey(); if (s3 !== peg$FAILED) { s4 = []; s5 = peg$currPos; s6 = []; s7 = peg$parseWhitespace(); while (s7 !== peg$FAILED) { s6.push(s7); s7 = peg$parseWhitespace(); } if (s6 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 46) { s7 = peg$c71; peg$currPos++; } else { s7 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c72); } } if (s7 !== peg$FAILED) { s8 = []; s9 = peg$parseWhitespace(); while (s9 !== peg$FAILED) { s8.push(s9); s9 = peg$parseWhitespace(); } if (s8 !== peg$FAILED) { s9 = peg$parseKey(); if (s9 !== peg$FAILED) { s6 = [s6, s7, s8, s9]; s5 = s6; } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } while (s5 !== peg$FAILED) { s4.push(s5); s5 = peg$currPos; s6 = []; s7 = peg$parseWhitespace(); while (s7 !== peg$FAILED) { s6.push(s7); s7 = peg$parseWhitespace(); } if (s6 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 46) { s7 = peg$c71; peg$currPos++; } else { s7 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c72); } } if (s7 !== peg$FAILED) { s8 = []; s9 = peg$parseWhitespace(); while (s9 !== peg$FAILED) { s8.push(s9); s9 = peg$parseWhitespace(); } if (s8 !== peg$FAILED) { s9 = peg$parseKey(); if (s9 !== peg$FAILED) { s6 = [s6, s7, s8, s9]; s5 = s6; } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } } else { peg$currPos = s5; s5 = peg$FAILED; } } if (s4 !== peg$FAILED) { s5 = []; s6 = peg$parseWhitespace(); while (s6 !== peg$FAILED) { s5.push(s6); s6 = peg$parseWhitespace(); } if (s5 !== peg$FAILED) { if (input.charCodeAt(peg$currPos) === 93) { s6 = peg$c104; peg$currPos++; } else { s6 = peg$FAILED; if (peg$silentFails === 0) { peg$fail(peg$c105); } } if (s6 !== peg$FAILED) { peg$savedPos = s0; s1 = peg$c114(s3, s4); s0 = s1; } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } } else { peg$currPos = s0; s0 = peg$FAILED; } return s0; } var genMsgRedefined, isFiniteNumber, isArray, hasOwnProperty, stringify, unescape, fromCodePoint, checkTableKey, findContext; genMsgRedefined = function (key) { return ('Value for ' + key + ' should not be redefined in the same table.'); }; isFiniteNumber = Number.isFinite || function (n) { return typeof n === 'number' && isFinite(n); }; isArray = Array.isArray || function (obj) { return Object.prototype.toString.call(obj) === '[object Array]'; }; hasOwnProperty = function (obj, key) { return Object.prototype.hasOwnProperty.call(obj, key); }; stringify = typeof JSON === 'object' && JSON ? JSON.stringify : function (o) { return '"' + String(o).replace(/[\x00-\x1F"\\]/g, function (c) { switch (c) { case '"': case '\\': return '\\' + c; case '\t': return '\\t'; case '\n': return '\\n'; case '\r': return '\\r'; case '\b': return '\\b'; case '\f': return '\\f'; default: var hex = c.charCodeAt(0).toString(16); return '\\u' + '0000'.substr(hex.length) + hex; } }) + '"'; }; unescape = function (c) { switch (c) { case '"': case '\\': return c; case 't': return '\t'; case 'n': return '\n'; case 'r': return '\r'; case 'b': return '\b'; case 'f': return '\f'; default: error(stringify(c) + ' cannot be escaped.'); } }; fromCodePoint = function (codepoint) { if (!isFiniteNumber(codepoint) || codepoint < 0 || codepoint > 0x10FFFF) { error('U+' + codepoint.toString(16) + ' is not a valid Unicode code point.'); } if (String.fromCodePoint) { return String.fromCodePoint(codepoint); } // See: punnycode.ucs2.encode from https://github.com/bestiejs/punycode.js var c = ''; if (codepoint > 0xFFFF) { codepoint -= 0x10000; c += String.fromCharCode((codepoint >>> 10) & 0x3FF | 0xD800); codepoint = 0xDC00 | codepoint & 0x3FF; } c += String.fromCharCode(codepoint); return c; }; checkTableKey = function (table, k) { if (hasOwnProperty(table, k)) { error(genMsgRedefined(stringify(k))); } }; findContext = function (table, isTableArray, path) { var s = ''; for (var i = 0, l = path.length; i < l; i++) { var k = path[i]; s += (s ? '.' : '') + stringify(k); if (!hasOwnProperty(table, k)) { if (isTableArray && i + 1 === l) { var t = {}; table[k] = [t]; table = t; g_table_arrays[s] = true; } else { table = table[k] = {}; g_tables[s] = true; } } else { if (isTableArray) { if (isArray(table[k])) { if (!g_table_arrays[s]) { error(genMsgRedefined(s)); } if (i + 1 === l) { var t = {}; table[k].push(t); table = t; } else { s += '.' + stringify(table[k].length - 1); table = table[k][table[k].length-1]; } } else { if (!g_tables[s]) { error(genMsgRedefined(s)); } table = table[k]; } } else { if (isArray(table[k])) { if (!g_table_arrays[s] || i + 1 === l) { error(genMsgRedefined(s)); } s += '.' + stringify(table[k].length - 1); table = table[k][table[k].length-1]; } else { if (!g_tables[s]) { error(genMsgRedefined(s)); } table = table[k]; } } } } if (isTableArray) { if (!g_table_arrays[s]) { error(genMsgRedefined(s)); } } else { if (g_defined_tables[s] || g_table_arrays[s]) { error(genMsgRedefined(s)); } g_defined_tables[s] = true; } return { table: table, path: path }; }; var g_root = {}; // TOML table var g_context = { // current context table: g_root, path: [] }; var g_tables = {}; // paths to tables var g_defined_tables = {}; // paths to tables directly defined var g_table_arrays = {}; // paths to table arrays peg$result = peg$startRuleFunction(); if (peg$result !== peg$FAILED && peg$currPos === input.length) { return peg$result; } else { if (peg$result !== peg$FAILED && peg$currPos < input.length) { peg$fail(peg$endExpectation()); } throw peg$buildStructuredError( peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos) ); } } return { SyntaxError: peg$SyntaxError, parse: peg$parse }; })(); function subclass(child, parent) { function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); } function TomlSyntaxError(message, offset, line, column) { this.message = message; this.offset = offset; this.line = line; this.column = column; } subclass(TomlSyntaxError, SyntaxError); var parser$1 = parser$2; var toml = { parse: function (src) { try { return parser$1.parse(src); } catch (err) { if (err instanceof parser$1.SyntaxError) { err.line = err.location.start.line; err.column = err.location.start.column; err.offset = err.location.start.offset; throw new TomlSyntaxError( err.message, err.location.start.offset, err.location.start.line, err.location.start.column); } else { throw err; } } }, SyntaxError: TomlSyntaxError }; var toml_1 = toml; /* Very simple logger interface. Each module is expected to create its own logger by doing e.g.: const logger = getLogger('my-prefix'); and then use it instead of console: logger.info('hello', 'world'); logger.warn('...'); logger.error('...'); The logger automatically adds the prefix "[my-prefix]" to all logs. E.g., the above call would print: [my-prefix] hello world logger.log is intentionally omitted. The idea is that PyScript should not write anything to console.log, to leave it free for the user. Currently, the logger does not to anything more than that. In the future, we might want to add additional features such as the ability to enable/disable logs on a global or per-module basis. */ const _cache = new Map(); function getLogger(prefix) { let logger = _cache.get(prefix); if (logger === undefined) { logger = _makeLogger(prefix); _cache.set(prefix, logger); } return logger; } function _makeLogger(prefix) { prefix = `[${prefix}] `; function make(level) { const out_fn = console[level].bind(console); function fn(fmt, ...args) { out_fn(prefix + fmt, ...args); } return fn; } // 'log' is intentionally omitted const debug = make('debug'); const info = make('info'); const warn = make('warn'); const error = make('error'); return { debug, info, warn, error }; } /** * @fileoverview Version of pyscript * The version is based on calver which contains YEAR.MONTH.DAY.MODIFIER. * The Modifier can be an optional text tag, such as "dev", "rc", etc. * * We are adding this file because we can't add version in main.js due to * circular imports. */ const version = '2022.12.1.dev'; const CLOSEBUTTON = ``; /* These error codes are used to identify the type of error that occurred. The convention is: * PY0 - errors that occur when fetching * PY1 - errors that occur in config * Py2 - errors that occur in plugins * PY9 - Deprecation errors */ var ErrorCode; (function (ErrorCode) { ErrorCode["GENERIC"] = "PY0000"; ErrorCode["FETCH_ERROR"] = "PY0001"; ErrorCode["FETCH_NAME_ERROR"] = "PY0002"; // Currently these are created depending on error code received from fetching ErrorCode["FETCH_UNAUTHORIZED_ERROR"] = "PY0401"; ErrorCode["FETCH_FORBIDDEN_ERROR"] = "PY0403"; ErrorCode["FETCH_NOT_FOUND_ERROR"] = "PY0404"; ErrorCode["FETCH_SERVER_ERROR"] = "PY0500"; ErrorCode["FETCH_UNAVAILABLE_ERROR"] = "PY0503"; ErrorCode["BAD_CONFIG"] = "PY1000"; ErrorCode["MICROPIP_INSTALL_ERROR"] = "PY1001"; ErrorCode["BAD_PLUGIN_FILE_EXTENSION"] = "PY2000"; ErrorCode["NO_DEFAULT_EXPORT"] = "PY2001"; ErrorCode["TOP_LEVEL_AWAIT"] = "PY9000"; })(ErrorCode || (ErrorCode = {})); class UserError extends Error { constructor(errorCode, message, t = 'text') { super(message); this.errorCode = errorCode; this.name = 'UserError'; this.messageType = t; this.message = `(${errorCode}): ${message}`; } } class FetchError extends UserError { constructor(errorCode, message) { super(errorCode, message); this.name = 'FetchError'; } } class InstallError extends UserError { constructor(errorCode, message) { super(errorCode, message); this.name = 'InstallError'; } } function _createAlertBanner(message, level = 'error', messageType = 'text', logMessage = true) { // eslint-disable-next-line @typescript-eslint/restrict-template-expressions switch (`log-${level}-${logMessage}`) { case 'log-error-true': console.error(message); break; case 'log-warning-true': console.warn(message); break; } const banner = document.createElement('div'); banner.className = `alert-banner py-${level}`; if (messageType === 'html') { banner.innerHTML = message; } else { banner.textContent = message; } if (level === 'warning') { const closeButton = document.createElement('button'); closeButton.id = 'alert-close-button'; closeButton.addEventListener('click', () => { banner.remove(); }); closeButton.innerHTML = CLOSEBUTTON; banner.appendChild(closeButton); } document.body.prepend(banner); } function escape(str) { return str.replace(//g, '>'); } function htmlDecode(input) { const doc = new DOMParser().parseFromString(ltrim(escape(input)), 'text/html'); return doc.documentElement.textContent; } function ltrim(code) { const lines = code.split('\n'); if (lines.length == 0) return code; const lengths = lines .filter(line => line.trim().length != 0) .map(line => { return line.match(/^\s*/)?.pop()?.length; }); const k = Math.min(...lengths); return k != 0 ? lines.map(line => line.substring(k)).join('\n') : code; } let _uniqueIdCounter = 0; function ensureUniqueId(el) { if (el.id === '') el.id = `py-internal-${_uniqueIdCounter++}`; } function showWarning(msg, messageType = 'text') { _createAlertBanner(msg, 'warning', messageType); } function readTextFromPath(path) { const request = new XMLHttpRequest(); request.open('GET', path, false); request.send(); const returnValue = request.responseText; return returnValue; } function globalExport(name, obj) { // attach the given object to the global object, so that it is globally // visible everywhere. Should be used very sparingly! globalThis[name] = obj; } function getAttribute(el, attr) { if (el.hasAttribute(attr)) { const value = el.getAttribute(attr); if (value) { return value; } } return null; } function joinPaths(parts, separator = '/') { const res = parts .map(function (part) { return part.trim().replace(/(^[/]*|[/]*$)/g, ''); }) .filter(p => p !== '') .join(separator || '/'); if (parts[0].startsWith('/')) { return '/' + res; } return res; } function createDeprecationWarning(msg, elementName) { createSingularWarning(msg, elementName); } /** Adds a warning banner with content {msg} at the top of the page if * and only if no banner containing the {sentinelText} already exists. * If sentinelText is null, the full text of {msg} is used instead * * @param msg {string} The full text content of the warning banner to be displayed * @param sentinelText {string} [null] The text to match against existing warning banners. * If null, the full text of 'msg' is used instead. */ function createSingularWarning(msg, sentinelText = null) { const banners = document.getElementsByClassName('alert-banner py-warning'); let bannerCount = 0; for (const banner of banners) { if (banner.innerHTML.includes(sentinelText ? sentinelText : msg)) { bannerCount++; } } if (bannerCount == 0) { _createAlertBanner(msg, 'warning'); } } /** * @returns A new asynchronous lock * @private */ function createLock() { // This is a promise that is resolved when the lock is open, not resolved when lock is held. let _lock = Promise.resolve(); /** * Acquire the async lock * @returns A zero argument function that releases the lock. * @private */ async function acquireLock() { const old_lock = _lock; let releaseLock; _lock = new Promise(resolve => (releaseLock = resolve)); await old_lock; return releaseLock; } return acquireLock; } const logger$b = getLogger('py-config'); const allKeys = { string: ['name', 'description', 'version', 'type', 'author_name', 'author_email', 'license'], number: ['schema_version'], array: ['runtimes', 'interpreters', 'packages', 'fetch', 'plugins'], }; const defaultConfig$1 = { schema_version: 1, type: 'app', interpreters: [ { src: 'https://cdn.jsdelivr.net/pyodide/v0.22.1/full/pyodide.js', name: 'pyodide-0.22.1', lang: 'python', }, ], // This is for backward compatibility, we need to remove it in the future runtimes: [], packages: [], fetch: [], plugins: [], }; function loadConfigFromElement(el) { let srcConfig; let inlineConfig; if (el === null) { srcConfig = {}; inlineConfig = {}; } else { const configType = getAttribute(el, 'type') || 'toml'; srcConfig = extractFromSrc(el, configType); inlineConfig = extractFromInline(el, configType); } srcConfig = mergeConfig(srcConfig, defaultConfig$1); const result = mergeConfig(inlineConfig, srcConfig); result.pyscript = { version, time: new Date().toISOString(), }; return result; } function extractFromSrc(el, configType) { const src = getAttribute(el, 'src'); if (src) { logger$b.info('loading ', src); return validateConfig(readTextFromPath(src), configType); } return {}; } function extractFromInline(el, configType) { if (el.innerHTML !== '') { logger$b.info('loading content'); return validateConfig(htmlDecode(el.innerHTML), configType); } return {}; } function fillUserData(inputConfig, resultConfig) { for (const key in inputConfig) { // fill in all extra keys ignored by the validator if (!(key in defaultConfig$1)) { resultConfig[key] = inputConfig[key]; } } return resultConfig; } function mergeConfig(inlineConfig, externalConfig) { if (Object.keys(inlineConfig).length === 0 && Object.keys(externalConfig).length === 0) { return defaultConfig$1; } else if (Object.keys(inlineConfig).length === 0) { return externalConfig; } else if (Object.keys(externalConfig).length === 0) { return inlineConfig; } else { let merged = {}; for (const keyType in allKeys) { const keys = allKeys[keyType]; keys.forEach(function (item) { if (keyType === 'boolean') { merged[item] = typeof inlineConfig[item] !== 'undefined' ? inlineConfig[item] : externalConfig[item]; } else { merged[item] = inlineConfig[item] || externalConfig[item]; } }); } // fill extra keys from external first // they will be overridden by inline if extra keys also clash merged = fillUserData(externalConfig, merged); merged = fillUserData(inlineConfig, merged); return merged; } } function parseConfig(configText, configType = 'toml') { if (configType === 'toml') { // TOML parser is soft and can parse even JSON strings, this additional check prevents it. if (configText.trim()[0] === '{') { throw new UserError(ErrorCode.BAD_CONFIG, `The config supplied: ${configText} is an invalid TOML and cannot be parsed`); } try { return toml_1.parse(configText); } catch (err) { const errMessage = err.toString(); throw new UserError(ErrorCode.BAD_CONFIG, `The config supplied: ${configText} is an invalid TOML and cannot be parsed: ${errMessage}`); } } else if (configType === 'json') { try { return JSON.parse(configText); } catch (err) { const errMessage = err.toString(); throw new UserError(ErrorCode.BAD_CONFIG, `The config supplied: ${configText} is an invalid JSON and cannot be parsed: ${errMessage}`); } } else { throw new UserError(ErrorCode.BAD_CONFIG, `The type of config supplied '${configType}' is not supported, supported values are ["toml", "json"]`); } } function validateConfig(configText, configType = 'toml') { const config = parseConfig(configText, configType); const finalConfig = {}; for (const keyType in allKeys) { const keys = allKeys[keyType]; keys.forEach(function (item) { if (validateParamInConfig(item, keyType, config)) { if (item === 'interpreters') { finalConfig[item] = []; const interpreters = config[item]; interpreters.forEach(function (eachInterpreter) { const interpreterConfig = {}; for (const eachInterpreterParam in eachInterpreter) { if (validateParamInConfig(eachInterpreterParam, 'string', eachInterpreter)) { interpreterConfig[eachInterpreterParam] = eachInterpreter[eachInterpreterParam]; } } finalConfig[item].push(interpreterConfig); }); } else if (item === 'runtimes') { // This code is a bit of a mess, but it's used for backwards // compatibility with the old runtimes config. It should be // removed when we remove support for the old config. // We also need the warning here since we are pushing // runtimes to `interpreter` and we can't show the warning // in main.js createDeprecationWarning('The configuration option `config.runtimes` is deprecated. ' + 'Please use `config.interpreters` instead.', ''); finalConfig['interpreters'] = []; const interpreters = config[item]; interpreters.forEach(function (eachInterpreter) { const interpreterConfig = {}; for (const eachInterpreterParam in eachInterpreter) { if (validateParamInConfig(eachInterpreterParam, 'string', eachInterpreter)) { interpreterConfig[eachInterpreterParam] = eachInterpreter[eachInterpreterParam]; } } finalConfig['interpreters'].push(interpreterConfig); }); } else if (item === 'fetch') { finalConfig[item] = []; const fetchList = config[item]; fetchList.forEach(function (eachFetch) { const eachFetchConfig = {}; for (const eachFetchConfigParam in eachFetch) { const targetType = eachFetchConfigParam === 'files' ? 'array' : 'string'; if (validateParamInConfig(eachFetchConfigParam, targetType, eachFetch)) { eachFetchConfig[eachFetchConfigParam] = eachFetch[eachFetchConfigParam]; } } finalConfig[item].push(eachFetchConfig); }); } else { finalConfig[item] = config[item]; } } }); } return fillUserData(config, finalConfig); } function validateParamInConfig(paramName, paramType, config) { if (paramName in config) { return paramType === 'array' ? Array.isArray(config[paramName]) : typeof config[paramName] === paramType; } return false; } /** * This is a fetch wrapper that handles any non 200 responses and throws a * FetchError with the right ErrorCode. This is useful because our FetchError * will automatically create an alert banner. * * @param url - URL to fetch * @param options - options to pass to fetch * @returns Response */ async function robustFetch(url, options) { let response; // Note: We need to wrap fetch into a try/catch block because fetch // throws a TypeError if the URL is invalid such as http://blah.blah try { response = await fetch(url, options); } catch (err) { const error = err; let errMsg; if (url.startsWith('http')) { errMsg = `Fetching from URL ${url} failed with error ` + `'${error.message}'. Are your filename and path correct?`; } else { errMsg = `PyScript: Access to local files (using "Paths:" in <py-config>) is not available when directly opening a HTML file; you must use a webserver to serve the additional files. See this reference on starting a simple webserver with Python. `; } throw new FetchError(ErrorCode.FETCH_ERROR, errMsg); } // Note that response.ok is true for 200-299 responses if (!response.ok) { const errorMsg = `Fetching from URL ${url} failed with error ${response.status} (${response.statusText}). Are your filename and path correct?`; switch (response.status) { case 404: throw new FetchError(ErrorCode.FETCH_NOT_FOUND_ERROR, errorMsg); case 401: throw new FetchError(ErrorCode.FETCH_UNAUTHORIZED_ERROR, errorMsg); case 403: throw new FetchError(ErrorCode.FETCH_FORBIDDEN_ERROR, errorMsg); case 500: throw new FetchError(ErrorCode.FETCH_SERVER_ERROR, errorMsg); case 503: throw new FetchError(ErrorCode.FETCH_UNAVAILABLE_ERROR, errorMsg); default: throw new FetchError(ErrorCode.FETCH_ERROR, errorMsg); } } return response; } const logger$a = getLogger('pyscript/pyodide'); /* RemoteInterpreter class is responsible to process requests from the `InterpreterClient` class -- these can be requests for installation of a package, executing code, etc. Currently, the only interpreter available is Pyodide as indicated by the `InterpreterInterface` type above. This serves as a Union of types of different interpreters which will be added in near future. Methods available handle loading of the interpreter, initialization, running code, loading and installation of packages, loading from files etc. The class will be turned `abstract` in future, to support more runtimes such as MicroPython. */ class RemoteInterpreter extends Object { constructor(src = 'https://cdn.jsdelivr.net/pyodide/v0.22.1/full/pyodide.js') { super(); this.src = src; } /** * loads the interface for the interpreter and saves an instance of it * in the `this.interface` property along with calling of other * additional convenience functions. * */ /** * Although `loadPyodide` is used below, * notice that it is not imported i.e. * import { loadPyodide } from 'pyodide'; * is not used at the top of this file. * * This is because, if it's used, loadPyodide * behaves mischievously i.e. it tries to load * `pyodide.asm.js` and `pyodide_py.tar` but * with paths that are wrong such as: * * http://127.0.0.1:8080/build/pyodide_py.tar * which results in a 404 since `build` doesn't * contain these files and is clearly the wrong * path. */ async loadInterpreter(config, stdio) { this.interface = await loadPyodide({ stdout: (msg) => { stdio.stdout_writeline(msg); }, stderr: (msg) => { stdio.stderr_writeline(msg); }, fullStdLib: false, }); // TODO: Remove this once `runtimes` is removed! this.interpreter = this.interface; this.globals = this.interface.globals; if (config.packages) { logger$a.info('Found packages in configuration to install. Loading micropip...'); await this.loadPackage('micropip'); } logger$a.info('pyodide loaded and initialized'); await this.run('print("Python initialization complete")'); } /* eslint-disable */ async run(code) { /** * eslint wants `await` keyword to be used i.e. * { result: await this.interface.runPython(code) } * However, `await` is not a no-op (no-operation) i.e. * `await 42` is NOT the same as `42` i.e. if the awaited * thing is not a promise, it is wrapped inside a promise and * that promise is awaited. Thus, it changes the execution order. * See https://stackoverflow.com/questions/55262996/does-awaiting-a-non-promise-have-any-detectable-effect * Thus, `eslint` is disabled for this block / snippet. */ /** * The output of `runPython` is wrapped inside an object * since an object is not thennable and avoids return of * a coroutine directly. This is so we do not `await` the results * of the underlying python execution, even if it's an * awaitable object (Future, Task, etc.) */ return { result: this.interface.runPython(code) }; } /* eslint-enable */ /** * delegates the registration of JS modules to * the underlying interface. * */ registerJsModule(name, module) { this.interface.registerJsModule(name, module); } /** * delegates the loading of packages to * the underlying interface. * */ async loadPackage(names) { logger$a.info(`pyodide.loadPackage: ${names.toString()}`); // the new way in v0.22.1 is to pass it as a dict of options i.e. // { messageCallback: logger.info.bind(logger), errorCallback: logger.info.bind(logger) } // but one of our tests tries to use a locally downloaded older version of pyodide // for which the signature of `loadPackage` accepts the above params as args i.e. // the call uses `logger.info.bind(logger), logger.info.bind(logger)`. const pyodide_version = (await this.run("import sys; sys.modules['pyodide'].__version__")).result.toString(); if (pyodide_version.startsWith('0.22')) { await this.interface.loadPackage(names, { messageCallback: logger$a.info.bind(logger$a), errorCallback: logger$a.info.bind(logger$a), }); } else { await this.interface.loadPackage(names, logger$a.info.bind(logger$a), logger$a.info.bind(logger$a)); } } /** * delegates the installation of packages * (using a package manager, which can be specific to * the interface) to the underlying interface. * * For Pyodide, we use `micropip` * */ async installPackage(package_name) { if (package_name.length > 0) { logger$a.info(`micropip install ${package_name.toString()}`); const micropip = this.interface.pyimport('micropip'); try { await micropip.install(package_name); micropip.destroy(); } catch (e) { let exceptionMessage = `Unable to install package(s) '` + package_name + `'.`; // If we can't fetch `package_name` micropip.install throws a huge // Python traceback in `e.message` this logic is to handle the // error and throw a more sensible error message instead of the // huge traceback. if (e.message.includes("Can't find a pure Python 3 wheel")) { exceptionMessage += ` Reason: Can't find a pure Python 3 Wheel for package(s) '` + package_name + `'. See: https://pyodide.org/en/stable/usage/faq.html#micropip-can-t-find-a-pure-python-wheel ` + `for more information.`; } else if (e.message.includes("Can't fetch metadata")) { exceptionMessage += ' Unable to find package in PyPI. ' + 'Please make sure you have entered a correct package name.'; } else { exceptionMessage += ` Reason: ${e.message}. Please open an issue at ` + `https://github.com/pyscript/pyscript/issues/new if you require help or ` + `you think it's a bug.`; } logger$a.error(e); throw new InstallError(ErrorCode.MICROPIP_INSTALL_ERROR, exceptionMessage); } } } /** * * @param path : the path in the filesystem * @param fetch_path : the path to be fetched * * Given a file available at `fetch_path` URL (eg: * `http://dummy.com/hi.py`), the function downloads the file and saves it * to the `path` (eg: `a/b/c/foo.py`) on the FS. * * Example usage: await loadFromFile(`a/b/c/foo.py`, * `http://dummy.com/hi.py`) * * Write content of `http://dummy.com/hi.py` to `a/b/c/foo.py` * * NOTE: The `path` parameter expects to have the `filename` in it i.e. * `a/b/c/foo.py` is valid while `a/b/c` (i.e. only the folders) are * incorrect. * * The path will be resolved relative to the current working directory, * which is initially `/home/pyodide`. So by default `a/b.py` will be placed * in `/home/pyodide/a/b.py`, `../a/b.py` will be placed into `/home/a/b.py` * and `/a/b.py` will be placed into `/a/b.py`. */ async loadFromFile(path, fetch_path) { // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-ignore path = this.interface._module.PATH_FS.resolve(path); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-ignore const dir = this.interface._module.PATH.dirname(path); this.interface.FS.mkdirTree(dir); // `robustFetch` checks for failures in getting a response const response = await robustFetch(fetch_path); const buffer = await response.arrayBuffer(); const data = new Uint8Array(buffer); this.interface.FS.writeFile(path, data, { canOwn: true }); } /** * delegates clearing importlib's module path * caches to the underlying interface */ invalidate_module_path_cache() { const importlib = this.interface.pyimport('importlib'); importlib.invalidate_caches(); } } const logger$9 = getLogger('pyscript/interpreter'); /* InterpreterClient class is responsible to request code execution (among other things) from a `RemoteInterpreter` */ class InterpreterClient extends Object { constructor(config, stdio) { super(); this.config = config; this._remote = new RemoteInterpreter(this.config.interpreters[0].src); this.stdio = stdio; } /** * initializes the remote interpreter, which further loads the underlying * interface. * */ async initializeRemote() { await this._remote.loadInterpreter(this.config, this.stdio); this.globals = this._remote.globals; } /** * delegates the code to be run to the underlying interface of * the remote interpreter. * Python exceptions are turned into JS exceptions. * */ async run(code) { return await this._remote.run(code); } /** * Same as run, but Python exceptions are not propagated: instead, they * are logged to the console. * * This is a bad API and should be killed/refactored/changed eventually, * but for now we have code which relies on it. * */ async runButDontRaise(code) { let result; try { result = (await this.run(code)).result; } catch (error) { logger$9.error('Error:', error); } return result; } } const logger$8 = getLogger('plugin'); class Plugin { /** Validate the configuration of the plugin and handle default values. * * Individual plugins are expected to check that the config keys/sections * which are relevant to them contains valid values, and to raise an error * if they contains unknown keys. * * This is also a good place where set default values for those keys which * are not specified by the user. * * This hook should **NOT** contain expensive operations, else it delays * the download of the python interpreter which is initiated later. */ configure(config) { } /** The preliminary initialization phase is complete and we are about to * download and launch the Python interpreter. * * We can assume that the page is already shown to the user and that the * DOM content has been loaded. This is a good place where to add tags to * the DOM, if needed. * * This hook should **NOT** contain expensive operations, else it delays * the download of the python interpreter which is initiated later. */ beforeLaunch(config) { } /** The Python interpreter has been launched, the virtualenv has been * installed and we are ready to execute user code. * * The tags will be executed after this hook. */ afterSetup(interpreter) { } /** The source of a > tag has been fetched, and we're about * to evaluate that source using the provided interpreter. * * @param options.interpreter The Interpreter object that will be used to evaluated the Python source code * @param options.src {string} The Python source code to be evaluated * @param options.pyScriptTag The HTML tag that originated the evaluation */ beforePyScriptExec(options) { } /** The Python in a has just been evaluated, but control * has not been ceded back to the JavaScript event loop yet * * @param options.interpreter The Interpreter object that will be used to evaluated the Python source code * @param options.src {string} The Python source code to be evaluated * @param options.pyScriptTag The HTML tag that originated the evaluation * @param options.result The returned result of evaluating the Python (if any) */ afterPyScriptExec(options) { } /** Startup complete. The interpreter is initialized and ready, user * scripts have been executed: the main initialization logic ends here and * the page is ready to accept user interactions. */ afterStartup(interpreter) { } /** Called when an UserError is raised */ onUserError(error) { } } class PluginManager { constructor() { this._plugins = []; this._pythonPlugins = []; } add(...plugins) { for (const p of plugins) this._plugins.push(p); } addPythonPlugin(plugin) { this._pythonPlugins.push(plugin); } configure(config) { for (const p of this._plugins) p.configure?.(config); for (const p of this._pythonPlugins) p.configure?.(config); } beforeLaunch(config) { for (const p of this._plugins) { try { p?.beforeLaunch?.(config); } catch (e) { logger$8.error(`Error while calling beforeLaunch hook of plugin ${p.constructor.name}`, e); } } } afterSetup(interpreter) { for (const p of this._plugins) { try { p.afterSetup?.(interpreter); } catch (e) { logger$8.error(`Error while calling afterSetup hook of plugin ${p.constructor.name}`, e); } } for (const p of this._pythonPlugins) p.afterSetup?.(interpreter); } afterStartup(interpreter) { for (const p of this._plugins) p.afterStartup?.(interpreter); for (const p of this._pythonPlugins) p.afterStartup?.(interpreter); } beforePyScriptExec(options) { for (const p of this._plugins) p.beforePyScriptExec?.(options); for (const p of this._pythonPlugins) p.beforePyScriptExec?.callKwargs(options); } afterPyScriptExec(options) { for (const p of this._plugins) p.afterPyScriptExec?.(options); for (const p of this._pythonPlugins) p.afterPyScriptExec?.callKwargs(options); } onUserError(error) { for (const p of this._plugins) p.onUserError?.(error); for (const p of this._pythonPlugins) p.onUserError?.(error); } } /** * Defines a new CustomElement (via customElement.defines) with `tag`, * where the new CustomElement is a proxy that delegates the logic to * pyPluginClass. * * @param tag - tag that will be used to define the new CustomElement (i.e: "py-script") * @param pyPluginClass - class that will be used to create instance to be * used as CustomElement logic handler. Any DOM event * received by the newly created CustomElement will be * delegated to that instance. */ function define_custom_element(tag, pyPluginClass) { logger$8.info(`creating plugin: ${tag}`); class ProxyCustomElement extends HTMLElement { constructor() { logger$8.debug(`creating ${tag} plugin instance`); super(); this.shadow = this.attachShadow({ mode: 'open' }); this.wrapper = document.createElement('slot'); this.shadow.appendChild(this.wrapper); this.originalInnerHTML = this.innerHTML; this.pyPluginInstance = pyPluginClass(this); } connectedCallback() { const innerHTML = this.pyPluginInstance.connect(); if (typeof innerHTML === 'string') this.innerHTML = innerHTML; } } customElements.define(tag, ProxyCustomElement); } const logger$7 = getLogger('pyexec'); async function pyExec(interpreter, pysrc, outElem) { //This is pyscript.py const pyscript_py = interpreter._remote.interface.pyimport('pyscript'); ensureUniqueId(outElem); pyscript_py.set_current_display_target(outElem.id); try { try { if (pyscript_py.uses_top_level_await(pysrc)) { throw new UserError(ErrorCode.TOP_LEVEL_AWAIT, 'The use of top-level "await", "async for", and ' + '"async with" has been removed.' + '\nPlease write a coroutine containing ' + 'your code and schedule it using asyncio.ensure_future() or similar.' + '\nSee https://docs.pyscript.net/latest/guides/asyncio.html for more information.'); } return await interpreter.run(pysrc); } catch (err) { // XXX: currently we display exceptions in the same position as // the output. But we probably need a better way to do that, // e.g. allowing plugins to intercept exceptions and display them // in a configurable way. displayPyException(err, outElem); return { result: undefined }; } } finally { pyscript_py.set_current_display_target(undefined); pyscript_py.destroy(); } } /** * Javascript API to call the python display() function * * Expected usage: * pyDisplay(interpreter, obj); * pyDisplay(interpreter, obj, { target: targetID }); */ function pyDisplay(interpreter, obj, kwargs) { const display = interpreter.globals.get('display'); if (kwargs === undefined) display(obj); else { display.callKwargs(obj, kwargs); } } function displayPyException(err, errElem) { //addClasses(errElem, ['py-error']) const pre = document.createElement('pre'); pre.className = 'py-error'; if (err.name === 'PythonError') { // err.message contains the python-level traceback (i.e. a string // starting with: "Traceback (most recent call last) ..." logger$7.error('Python exception:\n' + err.message); pre.innerText = err.message; } else { // this is very likely a normal JS exception. The best we can do is to // display it as is. logger$7.error('Non-python exception:\n' + err); pre.innerText = err; } errElem.appendChild(pre); } const logger$6 = getLogger('py-script'); function make_PyScript(interpreter, app) { class PyScript extends HTMLElement { async connectedCallback() { /** * Since connectedCallback is async, multiple py-script tags can be executed in * an order which is not particularly sequential. The locking mechanism here ensures * a sequential execution of multiple py-script tags present in one page. * * Concurrent access to the multiple py-script tags is thus avoided. */ let releaseLock; try { releaseLock = await app.tagExecutionLock(); ensureUniqueId(this); // Save innerHTML information in srcCode so we can access it later // once we clean innerHTML (which is required since we don't want // source code to be rendered on the screen) this.srcCode = this.innerHTML; const pySrc = await this.getPySrc(); this.innerHTML = ''; app.plugins.beforePyScriptExec({ interpreter: interpreter, src: pySrc, pyScriptTag: this }); const result = (await pyExec(interpreter, pySrc, this)).result; app.plugins.afterPyScriptExec({ interpreter: interpreter, src: pySrc, pyScriptTag: this, result: result, }); } finally { releaseLock(); } } async getPySrc() { if (this.hasAttribute('src')) { const url = this.getAttribute('src'); try { const response = await robustFetch(url); return await response.text(); } catch (e) { _createAlertBanner(e.message); this.innerHTML = ''; throw e; } } else { return htmlDecode(this.srcCode); } } } return PyScript; } /** Defines all possible py-on* and their corresponding event types */ const pyAttributeToEvent = new Map([ // Leaving pys-onClick and pys-onKeyDown for backward compatibility ['pys-onClick', 'click'], ['pys-onKeyDown', 'keydown'], ['py-onClick', 'click'], ['py-onKeyDown', 'keydown'], // Window Events ['py-afterprint', 'afterprint'], ['py-beforeprint', 'beforeprint'], ['py-beforeunload', 'beforeunload'], ['py-error', 'error'], ['py-hashchange', 'hashchange'], ['py-load', 'load'], ['py-message', 'message'], ['py-offline', 'offline'], ['py-online', 'online'], ['py-pagehide', 'pagehide'], ['py-pageshow', 'pageshow'], ['py-popstate', 'popstate'], ['py-resize', 'resize'], ['py-storage', 'storage'], ['py-unload', 'unload'], // Form Events ['py-blur', 'blur'], ['py-change', 'change'], ['py-contextmenu', 'contextmenu'], ['py-focus', 'focus'], ['py-input', 'input'], ['py-invalid', 'invalid'], ['py-reset', 'reset'], ['py-search', 'search'], ['py-select', 'select'], ['py-submit', 'submit'], // Keyboard Events ['py-keydown', 'keydown'], ['py-keypress', 'keypress'], ['py-keyup', 'keyup'], // Mouse Events ['py-click', 'click'], ['py-dblclick', 'dblclick'], ['py-mousedown', 'mousedown'], ['py-mousemove', 'mousemove'], ['py-mouseout', 'mouseout'], ['py-mouseover', 'mouseover'], ['py-mouseup', 'mouseup'], ['py-mousewheel', 'mousewheel'], ['py-wheel', 'wheel'], // Drag Events ['py-drag', 'drag'], ['py-dragend', 'dragend'], ['py-dragenter', 'dragenter'], ['py-dragleave', 'dragleave'], ['py-dragover', 'dragover'], ['py-dragstart', 'dragstart'], ['py-drop', 'drop'], ['py-scroll', 'scroll'], // Clipboard Events ['py-copy', 'copy'], ['py-cut', 'cut'], ['py-paste', 'paste'], // Media Events ['py-abort', 'abort'], ['py-canplay', 'canplay'], ['py-canplaythrough', 'canplaythrough'], ['py-cuechange', 'cuechange'], ['py-durationchange', 'durationchange'], ['py-emptied', 'emptied'], ['py-ended', 'ended'], ['py-loadeddata', 'loadeddata'], ['py-loadedmetadata', 'loadedmetadata'], ['py-loadstart', 'loadstart'], ['py-pause', 'pause'], ['py-play', 'play'], ['py-playing', 'playing'], ['py-progress', 'progress'], ['py-ratechange', 'ratechange'], ['py-seeked', 'seeked'], ['py-seeking', 'seeking'], ['py-stalled', 'stalled'], ['py-suspend', 'suspend'], ['py-timeupdate', 'timeupdate'], ['py-volumechange', 'volumechange'], ['py-waiting', 'waiting'], // Misc Events ['py-toggle', 'toggle'], ]); /** Initialize all elements with py-* handlers attributes */ function initHandlers(interpreter) { logger$6.debug('Initializing py-* event handlers...'); for (const pyAttribute of pyAttributeToEvent.keys()) { createElementsWithEventListeners(interpreter, pyAttribute); } } /** Initializes an element with the given py-on* attribute and its handler */ function createElementsWithEventListeners(interpreter, pyAttribute) { const matches = document.querySelectorAll(`[${pyAttribute}]`); for (const el of matches) { // If the element doesn't have an id, let's add one automatically! if (el.id.length === 0) { ensureUniqueId(el); } const handlerCode = el.getAttribute(pyAttribute); const event = pyAttributeToEvent.get(pyAttribute); if (pyAttribute === 'pys-onClick' || pyAttribute === 'pys-onKeyDown') { const msg = `The attribute 'pys-onClick' and 'pys-onKeyDown' are deprecated. Please 'py-click="myFunction()"' ` + ` or 'py-keydown="myFunction()"' instead.`; createDeprecationWarning(msg, msg); const source = ` from pyodide.ffi import create_proxy Element("${el.id}").element.addEventListener("${event}", create_proxy(${handlerCode})) `; // We meed to run the source code in a try/catch block, because // the source code may contain a syntax error, which will cause // the splashscreen to not be removed. try { interpreter.run(source); } catch (e) { logger$6.error(e.message); } } else { el.addEventListener(event, () => { void (async () => { try { await interpreter.run(handlerCode); } catch (err) { displayPyException(err, el.parentElement); } })(); }); } // TODO: Should we actually map handlers in JS instead of Python? // el.onclick = (evt: any) => { // console.log("click"); // new Promise((resolve, reject) => { // setTimeout(() => { // console.log('Inside') // }, 300); // }).then(() => { // console.log("resolved") // }); // // let handlerCode = el.getAttribute('py-onClick'); // // pyodide.runPython(handlerCode); // } } } /** Mount all elements with attribute py-mount into the Python namespace */ async function mountElements(interpreter) { const matches = document.querySelectorAll('[py-mount]'); logger$6.info(`py-mount: found ${matches.length} elements`); let source = ''; for (const el of matches) { const mountName = el.getAttribute('py-mount') || el.id.split('-').join('_'); source += `\n${mountName} = Element("${el.id}")`; } await interpreter.run(source); } function calculatePaths(fetch_cfg) { const fetchPaths = []; const paths = []; fetch_cfg.forEach(function (each_fetch_cfg) { const from = each_fetch_cfg.from || ''; const to_folder = each_fetch_cfg.to_folder || '.'; const to_file = each_fetch_cfg.to_file; const files = each_fetch_cfg.files; if (files !== undefined) { if (to_file !== undefined) { throw new UserError(ErrorCode.BAD_CONFIG, `Cannot use 'to_file' and 'files' parameters together!`); } for (const each_f of files) { const each_fetch_path = joinPaths([from, each_f]); fetchPaths.push(each_fetch_path); const each_path = joinPaths([to_folder, each_f]); paths.push(each_path); } } else { fetchPaths.push(from); const filename = to_file || from.split('/').pop(); if (filename === '') { throw new UserError(ErrorCode.BAD_CONFIG, `Couldn't determine the filename from the path ${from}, please supply 'to_file' parameter.`); } else { paths.push(joinPaths([to_folder, filename])); } } }); return [paths, fetchPaths]; } /** The data structure for documents. @nonabstract */ class Text { /** @internal */ constructor() { } /** Get the line description around the given position. */ lineAt(pos) { if (pos < 0 || pos > this.length) throw new RangeError(`Invalid position ${pos} in document of length ${this.length}`); return this.lineInner(pos, false, 1, 0); } /** Get the description for the given (1-based) line number. */ line(n) { if (n < 1 || n > this.lines) throw new RangeError(`Invalid line number ${n} in ${this.lines}-line document`); return this.lineInner(n, true, 1, 0); } /** Replace a range of the text with the given content. */ replace(from, to, text) { let parts = []; this.decompose(0, from, parts, 2 /* Open.To */); if (text.length) text.decompose(0, text.length, parts, 1 /* Open.From */ | 2 /* Open.To */); this.decompose(to, this.length, parts, 1 /* Open.From */); return TextNode.from(parts, this.length - (to - from) + text.length); } /** Append another document to this one. */ append(other) { return this.replace(this.length, this.length, other); } /** Retrieve the text between the given points. */ slice(from, to = this.length) { let parts = []; this.decompose(from, to, parts, 0); return TextNode.from(parts, to - from); } /** Test whether this text is equal to another instance. */ eq(other) { if (other == this) return true; if (other.length != this.length || other.lines != this.lines) return false; let start = this.scanIdentical(other, 1), end = this.length - this.scanIdentical(other, -1); let a = new RawTextCursor(this), b = new RawTextCursor(other); for (let skip = start, pos = start;;) { a.next(skip); b.next(skip); skip = 0; if (a.lineBreak != b.lineBreak || a.done != b.done || a.value != b.value) return false; pos += a.value.length; if (a.done || pos >= end) return true; } } /** Iterate over the text. When `dir` is `-1`, iteration happens from end to start. This will return lines and the breaks between them as separate strings. */ iter(dir = 1) { return new RawTextCursor(this, dir); } /** Iterate over a range of the text. When `from` > `to`, the iterator will run in reverse. */ iterRange(from, to = this.length) { return new PartialTextCursor(this, from, to); } /** Return a cursor that iterates over the given range of lines, _without_ returning the line breaks between, and yielding empty strings for empty lines. When `from` and `to` are given, they should be 1-based line numbers. */ iterLines(from, to) { let inner; if (from == null) { inner = this.iter(); } else { if (to == null) to = this.lines + 1; let start = this.line(from).from; inner = this.iterRange(start, Math.max(start, to == this.lines + 1 ? this.length : to <= 1 ? 0 : this.line(to - 1).to)); } return new LineCursor(inner); } /** @internal */ toString() { return this.sliceString(0); } /** Convert the document to an array of lines (which can be deserialized again via [`Text.of`](https://codemirror.net/6/docs/ref/#state.Text^of)). */ toJSON() { let lines = []; this.flatten(lines); return lines; } /** Create a `Text` instance for the given array of lines. */ static of(text) { if (text.length == 0) throw new RangeError("A document must have at least one line"); if (text.length == 1 && !text[0]) return Text.empty; return text.length <= 32 /* Tree.Branch */ ? new TextLeaf(text) : TextNode.from(TextLeaf.split(text, [])); } } // Leaves store an array of line strings. There are always line breaks // between these strings. Leaves are limited in size and have to be // contained in TextNode instances for bigger documents. class TextLeaf extends Text { constructor(text, length = textLength(text)) { super(); this.text = text; this.length = length; } get lines() { return this.text.length; } get children() { return null; } lineInner(target, isLine, line, offset) { for (let i = 0;; i++) { let string = this.text[i], end = offset + string.length; if ((isLine ? line : end) >= target) return new Line(offset, end, line, string); offset = end + 1; line++; } } decompose(from, to, target, open) { let text = from <= 0 && to >= this.length ? this : new TextLeaf(sliceText(this.text, from, to), Math.min(to, this.length) - Math.max(0, from)); if (open & 1 /* Open.From */) { let prev = target.pop(); let joined = appendText(text.text, prev.text.slice(), 0, text.length); if (joined.length <= 32 /* Tree.Branch */) { target.push(new TextLeaf(joined, prev.length + text.length)); } else { let mid = joined.length >> 1; target.push(new TextLeaf(joined.slice(0, mid)), new TextLeaf(joined.slice(mid))); } } else { target.push(text); } } replace(from, to, text) { if (!(text instanceof TextLeaf)) return super.replace(from, to, text); let lines = appendText(this.text, appendText(text.text, sliceText(this.text, 0, from)), to); let newLen = this.length + text.length - (to - from); if (lines.length <= 32 /* Tree.Branch */) return new TextLeaf(lines, newLen); return TextNode.from(TextLeaf.split(lines, []), newLen); } sliceString(from, to = this.length, lineSep = "\n") { let result = ""; for (let pos = 0, i = 0; pos <= to && i < this.text.length; i++) { let line = this.text[i], end = pos + line.length; if (pos > from && i) result += lineSep; if (from < end && to > pos) result += line.slice(Math.max(0, from - pos), to - pos); pos = end + 1; } return result; } flatten(target) { for (let line of this.text) target.push(line); } scanIdentical() { return 0; } static split(text, target) { let part = [], len = -1; for (let line of text) { part.push(line); len += line.length + 1; if (part.length == 32 /* Tree.Branch */) { target.push(new TextLeaf(part, len)); part = []; len = -1; } } if (len > -1) target.push(new TextLeaf(part, len)); return target; } } // Nodes provide the tree structure of the `Text` type. They store a // number of other nodes or leaves, taking care to balance themselves // on changes. There are implied line breaks _between_ the children of // a node (but not before the first or after the last child). class TextNode extends Text { constructor(children, length) { super(); this.children = children; this.length = length; this.lines = 0; for (let child of children) this.lines += child.lines; } lineInner(target, isLine, line, offset) { for (let i = 0;; i++) { let child = this.children[i], end = offset + child.length, endLine = line + child.lines - 1; if ((isLine ? endLine : end) >= target) return child.lineInner(target, isLine, line, offset); offset = end + 1; line = endLine + 1; } } decompose(from, to, target, open) { for (let i = 0, pos = 0; pos <= to && i < this.children.length; i++) { let child = this.children[i], end = pos + child.length; if (from <= end && to >= pos) { let childOpen = open & ((pos <= from ? 1 /* Open.From */ : 0) | (end >= to ? 2 /* Open.To */ : 0)); if (pos >= from && end <= to && !childOpen) target.push(child); else child.decompose(from - pos, to - pos, target, childOpen); } pos = end + 1; } } replace(from, to, text) { if (text.lines < this.lines) for (let i = 0, pos = 0; i < this.children.length; i++) { let child = this.children[i], end = pos + child.length; // Fast path: if the change only affects one child and the // child's size remains in the acceptable range, only update // that child if (from >= pos && to <= end) { let updated = child.replace(from - pos, to - pos, text); let totalLines = this.lines - child.lines + updated.lines; if (updated.lines < (totalLines >> (5 /* Tree.BranchShift */ - 1)) && updated.lines > (totalLines >> (5 /* Tree.BranchShift */ + 1))) { let copy = this.children.slice(); copy[i] = updated; return new TextNode(copy, this.length - (to - from) + text.length); } return super.replace(pos, end, updated); } pos = end + 1; } return super.replace(from, to, text); } sliceString(from, to = this.length, lineSep = "\n") { let result = ""; for (let i = 0, pos = 0; i < this.children.length && pos <= to; i++) { let child = this.children[i], end = pos + child.length; if (pos > from && i) result += lineSep; if (from < end && to > pos) result += child.sliceString(from - pos, to - pos, lineSep); pos = end + 1; } return result; } flatten(target) { for (let child of this.children) child.flatten(target); } scanIdentical(other, dir) { if (!(other instanceof TextNode)) return 0; let length = 0; let [iA, iB, eA, eB] = dir > 0 ? [0, 0, this.children.length, other.children.length] : [this.children.length - 1, other.children.length - 1, -1, -1]; for (;; iA += dir, iB += dir) { if (iA == eA || iB == eB) return length; let chA = this.children[iA], chB = other.children[iB]; if (chA != chB) return length + chA.scanIdentical(chB, dir); length += chA.length + 1; } } static from(children, length = children.reduce((l, ch) => l + ch.length + 1, -1)) { let lines = 0; for (let ch of children) lines += ch.lines; if (lines < 32 /* Tree.Branch */) { let flat = []; for (let ch of children) ch.flatten(flat); return new TextLeaf(flat, length); } let chunk = Math.max(32 /* Tree.Branch */, lines >> 5 /* Tree.BranchShift */), maxChunk = chunk << 1, minChunk = chunk >> 1; let chunked = [], currentLines = 0, currentLen = -1, currentChunk = []; function add(child) { let last; if (child.lines > maxChunk && child instanceof TextNode) { for (let node of child.children) add(node); } else if (child.lines > minChunk && (currentLines > minChunk || !currentLines)) { flush(); chunked.push(child); } else if (child instanceof TextLeaf && currentLines && (last = currentChunk[currentChunk.length - 1]) instanceof TextLeaf && child.lines + last.lines <= 32 /* Tree.Branch */) { currentLines += child.lines; currentLen += child.length + 1; currentChunk[currentChunk.length - 1] = new TextLeaf(last.text.concat(child.text), last.length + 1 + child.length); } else { if (currentLines + child.lines > chunk) flush(); currentLines += child.lines; currentLen += child.length + 1; currentChunk.push(child); } } function flush() { if (currentLines == 0) return; chunked.push(currentChunk.length == 1 ? currentChunk[0] : TextNode.from(currentChunk, currentLen)); currentLen = -1; currentLines = currentChunk.length = 0; } for (let child of children) add(child); flush(); return chunked.length == 1 ? chunked[0] : new TextNode(chunked, length); } } Text.empty = /*@__PURE__*/new TextLeaf([""], 0); function textLength(text) { let length = -1; for (let line of text) length += line.length + 1; return length; } function appendText(text, target, from = 0, to = 1e9) { for (let pos = 0, i = 0, first = true; i < text.length && pos <= to; i++) { let line = text[i], end = pos + line.length; if (end >= from) { if (end > to) line = line.slice(0, to - pos); if (pos < from) line = line.slice(from - pos); if (first) { target[target.length - 1] += line; first = false; } else target.push(line); } pos = end + 1; } return target; } function sliceText(text, from, to) { return appendText(text, [""], from, to); } class RawTextCursor { constructor(text, dir = 1) { this.dir = dir; this.done = false; this.lineBreak = false; this.value = ""; this.nodes = [text]; this.offsets = [dir > 0 ? 1 : (text instanceof TextLeaf ? text.text.length : text.children.length) << 1]; } nextInner(skip, dir) { this.done = this.lineBreak = false; for (;;) { let last = this.nodes.length - 1; let top = this.nodes[last], offsetValue = this.offsets[last], offset = offsetValue >> 1; let size = top instanceof TextLeaf ? top.text.length : top.children.length; if (offset == (dir > 0 ? size : 0)) { if (last == 0) { this.done = true; this.value = ""; return this; } if (dir > 0) this.offsets[last - 1]++; this.nodes.pop(); this.offsets.pop(); } else if ((offsetValue & 1) == (dir > 0 ? 0 : 1)) { this.offsets[last] += dir; if (skip == 0) { this.lineBreak = true; this.value = "\n"; return this; } skip--; } else if (top instanceof TextLeaf) { // Move to the next string let next = top.text[offset + (dir < 0 ? -1 : 0)]; this.offsets[last] += dir; if (next.length > Math.max(0, skip)) { this.value = skip == 0 ? next : dir > 0 ? next.slice(skip) : next.slice(0, next.length - skip); return this; } skip -= next.length; } else { let next = top.children[offset + (dir < 0 ? -1 : 0)]; if (skip > next.length) { skip -= next.length; this.offsets[last] += dir; } else { if (dir < 0) this.offsets[last]--; this.nodes.push(next); this.offsets.push(dir > 0 ? 1 : (next instanceof TextLeaf ? next.text.length : next.children.length) << 1); } } } } next(skip = 0) { if (skip < 0) { this.nextInner(-skip, (-this.dir)); skip = this.value.length; } return this.nextInner(skip, this.dir); } } class PartialTextCursor { constructor(text, start, end) { this.value = ""; this.done = false; this.cursor = new RawTextCursor(text, start > end ? -1 : 1); this.pos = start > end ? text.length : 0; this.from = Math.min(start, end); this.to = Math.max(start, end); } nextInner(skip, dir) { if (dir < 0 ? this.pos <= this.from : this.pos >= this.to) { this.value = ""; this.done = true; return this; } skip += Math.max(0, dir < 0 ? this.pos - this.to : this.from - this.pos); let limit = dir < 0 ? this.pos - this.from : this.to - this.pos; if (skip > limit) skip = limit; limit -= skip; let { value } = this.cursor.next(skip); this.pos += (value.length + skip) * dir; this.value = value.length <= limit ? value : dir < 0 ? value.slice(value.length - limit) : value.slice(0, limit); this.done = !this.value; return this; } next(skip = 0) { if (skip < 0) skip = Math.max(skip, this.from - this.pos); else if (skip > 0) skip = Math.min(skip, this.to - this.pos); return this.nextInner(skip, this.cursor.dir); } get lineBreak() { return this.cursor.lineBreak && this.value != ""; } } class LineCursor { constructor(inner) { this.inner = inner; this.afterBreak = true; this.value = ""; this.done = false; } next(skip = 0) { let { done, lineBreak, value } = this.inner.next(skip); if (done) { this.done = true; this.value = ""; } else if (lineBreak) { if (this.afterBreak) { this.value = ""; } else { this.afterBreak = true; this.next(); } } else { this.value = value; this.afterBreak = false; } return this; } get lineBreak() { return false; } } if (typeof Symbol != "undefined") { Text.prototype[Symbol.iterator] = function () { return this.iter(); }; RawTextCursor.prototype[Symbol.iterator] = PartialTextCursor.prototype[Symbol.iterator] = LineCursor.prototype[Symbol.iterator] = function () { return this; }; } /** This type describes a line in the document. It is created on-demand when lines are [queried](https://codemirror.net/6/docs/ref/#state.Text.lineAt). */ class Line { /** @internal */ constructor( /** The position of the start of the line. */ from, /** The position at the end of the line (_before_ the line break, or at the end of document for the last line). */ to, /** This line's line number (1-based). */ number, /** The line's content. */ text) { this.from = from; this.to = to; this.number = number; this.text = text; } /** The length of the line (not including any line break after it). */ get length() { return this.to - this.from; } } // Compressed representation of the Grapheme_Cluster_Break=Extend // information from // http://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakProperty.txt. // Each pair of elements represents a range, as an offet from the // previous range and a length. Numbers are in base-36, with the empty // string being a shorthand for 1. let extend = /*@__PURE__*/"lc,34,7n,7,7b,19,,,,2,,2,,,20,b,1c,l,g,,2t,7,2,6,2,2,,4,z,,u,r,2j,b,1m,9,9,,o,4,,9,,3,,5,17,3,3b,f,,w,1j,,,,4,8,4,,3,7,a,2,t,,1m,,,,2,4,8,,9,,a,2,q,,2,2,1l,,4,2,4,2,2,3,3,,u,2,3,,b,2,1l,,4,5,,2,4,,k,2,m,6,,,1m,,,2,,4,8,,7,3,a,2,u,,1n,,,,c,,9,,14,,3,,1l,3,5,3,,4,7,2,b,2,t,,1m,,2,,2,,3,,5,2,7,2,b,2,s,2,1l,2,,,2,4,8,,9,,a,2,t,,20,,4,,2,3,,,8,,29,,2,7,c,8,2q,,2,9,b,6,22,2,r,,,,,,1j,e,,5,,2,5,b,,10,9,,2u,4,,6,,2,2,2,p,2,4,3,g,4,d,,2,2,6,,f,,jj,3,qa,3,t,3,t,2,u,2,1s,2,,7,8,,2,b,9,,19,3,3b,2,y,,3a,3,4,2,9,,6,3,63,2,2,,1m,,,7,,,,,2,8,6,a,2,,1c,h,1r,4,1c,7,,,5,,14,9,c,2,w,4,2,2,,3,1k,,,2,3,,,3,1m,8,2,2,48,3,,d,,7,4,,6,,3,2,5i,1m,,5,ek,,5f,x,2da,3,3x,,2o,w,fe,6,2x,2,n9w,4,,a,w,2,28,2,7k,,3,,4,,p,2,5,,47,2,q,i,d,,12,8,p,b,1a,3,1c,,2,4,2,2,13,,1v,6,2,2,2,2,c,,8,,1b,,1f,,,3,2,2,5,2,,,16,2,8,,6m,,2,,4,,fn4,,kh,g,g,g,a6,2,gt,,6a,,45,5,1ae,3,,2,5,4,14,3,4,,4l,2,fx,4,ar,2,49,b,4w,,1i,f,1k,3,1d,4,2,2,1x,3,10,5,,8,1q,,c,2,1g,9,a,4,2,,2n,3,2,,,2,6,,4g,,3,8,l,2,1l,2,,,,,m,,e,7,3,5,5f,8,2,3,,,n,,29,,2,6,,,2,,,2,,2,6j,,2,4,6,2,,2,r,2,2d,8,2,,,2,2y,,,,2,6,,,2t,3,2,4,,5,77,9,,2,6t,,a,2,,,4,,40,4,2,2,4,,w,a,14,6,2,4,8,,9,6,2,3,1a,d,,2,ba,7,,6,,,2a,m,2,7,,2,,2,3e,6,3,,,2,,7,,,20,2,3,,,,9n,2,f0b,5,1n,7,t4,,1r,4,29,,f5k,2,43q,,,3,4,5,8,8,2,7,u,4,44,3,1iz,1j,4,1e,8,,e,,m,5,,f,11s,7,,h,2,7,,2,,5,79,7,c5,4,15s,7,31,7,240,5,gx7k,2o,3k,6o".split(",").map(s => s ? parseInt(s, 36) : 1); // Convert offsets into absolute values for (let i = 1; i < extend.length; i++) extend[i] += extend[i - 1]; function isExtendingChar(code) { for (let i = 1; i < extend.length; i += 2) if (extend[i] > code) return extend[i - 1] <= code; return false; } function isRegionalIndicator(code) { return code >= 0x1F1E6 && code <= 0x1F1FF; } const ZWJ = 0x200d; /** Returns a next grapheme cluster break _after_ (not equal to) `pos`, if `forward` is true, or before otherwise. Returns `pos` itself if no further cluster break is available in the string. Moves across surrogate pairs, extending characters (when `includeExtending` is true), characters joined with zero-width joiners, and flag emoji. */ function findClusterBreak(str, pos, forward = true, includeExtending = true) { return (forward ? nextClusterBreak : prevClusterBreak)(str, pos, includeExtending); } function nextClusterBreak(str, pos, includeExtending) { if (pos == str.length) return pos; // If pos is in the middle of a surrogate pair, move to its start if (pos && surrogateLow(str.charCodeAt(pos)) && surrogateHigh(str.charCodeAt(pos - 1))) pos--; let prev = codePointAt(str, pos); pos += codePointSize(prev); while (pos < str.length) { let next = codePointAt(str, pos); if (prev == ZWJ || next == ZWJ || includeExtending && isExtendingChar(next)) { pos += codePointSize(next); prev = next; } else if (isRegionalIndicator(next)) { let countBefore = 0, i = pos - 2; while (i >= 0 && isRegionalIndicator(codePointAt(str, i))) { countBefore++; i -= 2; } if (countBefore % 2 == 0) break; else pos += 2; } else { break; } } return pos; } function prevClusterBreak(str, pos, includeExtending) { while (pos > 0) { let found = nextClusterBreak(str, pos - 2, includeExtending); if (found < pos) return found; pos--; } return 0; } function surrogateLow(ch) { return ch >= 0xDC00 && ch < 0xE000; } function surrogateHigh(ch) { return ch >= 0xD800 && ch < 0xDC00; } /** Find the code point at the given position in a string (like the [`codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt) string method). */ function codePointAt(str, pos) { let code0 = str.charCodeAt(pos); if (!surrogateHigh(code0) || pos + 1 == str.length) return code0; let code1 = str.charCodeAt(pos + 1); if (!surrogateLow(code1)) return code0; return ((code0 - 0xd800) << 10) + (code1 - 0xdc00) + 0x10000; } /** Given a Unicode codepoint, return the JavaScript string that respresents it (like [`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)). */ function fromCodePoint(code) { if (code <= 0xffff) return String.fromCharCode(code); code -= 0x10000; return String.fromCharCode((code >> 10) + 0xd800, (code & 1023) + 0xdc00); } /** The amount of positions a character takes up a JavaScript string. */ function codePointSize(code) { return code < 0x10000 ? 1 : 2; } const DefaultSplit = /\r\n?|\n/; /** Distinguishes different ways in which positions can be mapped. */ var MapMode = /*@__PURE__*/(function (MapMode) { /** Map a position to a valid new position, even when its context was deleted. */ MapMode[MapMode["Simple"] = 0] = "Simple"; /** Return null if deletion happens across the position. */ MapMode[MapMode["TrackDel"] = 1] = "TrackDel"; /** Return null if the character _before_ the position is deleted. */ MapMode[MapMode["TrackBefore"] = 2] = "TrackBefore"; /** Return null if the character _after_ the position is deleted. */ MapMode[MapMode["TrackAfter"] = 3] = "TrackAfter"; return MapMode})(MapMode || (MapMode = {})); /** A change description is a variant of [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet) that doesn't store the inserted text. As such, it can't be applied, but is cheaper to store and manipulate. */ class ChangeDesc { // Sections are encoded as pairs of integers. The first is the // length in the current document, and the second is -1 for // unaffected sections, and the length of the replacement content // otherwise. So an insertion would be (0, n>0), a deletion (n>0, // 0), and a replacement two positive numbers. /** @internal */ constructor( /** @internal */ sections) { this.sections = sections; } /** The length of the document before the change. */ get length() { let result = 0; for (let i = 0; i < this.sections.length; i += 2) result += this.sections[i]; return result; } /** The length of the document after the change. */ get newLength() { let result = 0; for (let i = 0; i < this.sections.length; i += 2) { let ins = this.sections[i + 1]; result += ins < 0 ? this.sections[i] : ins; } return result; } /** False when there are actual changes in this set. */ get empty() { return this.sections.length == 0 || this.sections.length == 2 && this.sections[1] < 0; } /** Iterate over the unchanged parts left by these changes. `posA` provides the position of the range in the old document, `posB` the new position in the changed document. */ iterGaps(f) { for (let i = 0, posA = 0, posB = 0; i < this.sections.length;) { let len = this.sections[i++], ins = this.sections[i++]; if (ins < 0) { f(posA, posB, len); posB += len; } else { posB += ins; } posA += len; } } /** Iterate over the ranges changed by these changes. (See [`ChangeSet.iterChanges`](https://codemirror.net/6/docs/ref/#state.ChangeSet.iterChanges) for a variant that also provides you with the inserted text.) `fromA`/`toA` provides the extent of the change in the starting document, `fromB`/`toB` the extent of the replacement in the changed document. When `individual` is true, adjacent changes (which are kept separate for [position mapping](https://codemirror.net/6/docs/ref/#state.ChangeDesc.mapPos)) are reported separately. */ iterChangedRanges(f, individual = false) { iterChanges(this, f, individual); } /** Get a description of the inverted form of these changes. */ get invertedDesc() { let sections = []; for (let i = 0; i < this.sections.length;) { let len = this.sections[i++], ins = this.sections[i++]; if (ins < 0) sections.push(len, ins); else sections.push(ins, len); } return new ChangeDesc(sections); } /** Compute the combined effect of applying another set of changes after this one. The length of the document after this set should match the length before `other`. */ composeDesc(other) { return this.empty ? other : other.empty ? this : composeSets(this, other); } /** Map this description, which should start with the same document as `other`, over another set of changes, so that it can be applied after it. When `before` is true, map as if the changes in `other` happened before the ones in `this`. */ mapDesc(other, before = false) { return other.empty ? this : mapSet(this, other, before); } mapPos(pos, assoc = -1, mode = MapMode.Simple) { let posA = 0, posB = 0; for (let i = 0; i < this.sections.length;) { let len = this.sections[i++], ins = this.sections[i++], endA = posA + len; if (ins < 0) { if (endA > pos) return posB + (pos - posA); posB += len; } else { if (mode != MapMode.Simple && endA >= pos && (mode == MapMode.TrackDel && posA < pos && endA > pos || mode == MapMode.TrackBefore && posA < pos || mode == MapMode.TrackAfter && endA > pos)) return null; if (endA > pos || endA == pos && assoc < 0 && !len) return pos == posA || assoc < 0 ? posB : posB + ins; posB += ins; } posA = endA; } if (pos > posA) throw new RangeError(`Position ${pos} is out of range for changeset of length ${posA}`); return posB; } /** Check whether these changes touch a given range. When one of the changes entirely covers the range, the string `"cover"` is returned. */ touchesRange(from, to = from) { for (let i = 0, pos = 0; i < this.sections.length && pos <= to;) { let len = this.sections[i++], ins = this.sections[i++], end = pos + len; if (ins >= 0 && pos <= to && end >= from) return pos < from && end > to ? "cover" : true; pos = end; } return false; } /** @internal */ toString() { let result = ""; for (let i = 0; i < this.sections.length;) { let len = this.sections[i++], ins = this.sections[i++]; result += (result ? " " : "") + len + (ins >= 0 ? ":" + ins : ""); } return result; } /** Serialize this change desc to a JSON-representable value. */ toJSON() { return this.sections; } /** Create a change desc from its JSON representation (as produced by [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeDesc.toJSON). */ static fromJSON(json) { if (!Array.isArray(json) || json.length % 2 || json.some(a => typeof a != "number")) throw new RangeError("Invalid JSON representation of ChangeDesc"); return new ChangeDesc(json); } /** @internal */ static create(sections) { return new ChangeDesc(sections); } } /** A change set represents a group of modifications to a document. It stores the document length, and can only be applied to documents with exactly that length. */ class ChangeSet extends ChangeDesc { constructor(sections, /** @internal */ inserted) { super(sections); this.inserted = inserted; } /** Apply the changes to a document, returning the modified document. */ apply(doc) { if (this.length != doc.length) throw new RangeError("Applying change set to a document with the wrong length"); iterChanges(this, (fromA, toA, fromB, _toB, text) => doc = doc.replace(fromB, fromB + (toA - fromA), text), false); return doc; } mapDesc(other, before = false) { return mapSet(this, other, before, true); } /** Given the document as it existed _before_ the changes, return a change set that represents the inverse of this set, which could be used to go from the document created by the changes back to the document as it existed before the changes. */ invert(doc) { let sections = this.sections.slice(), inserted = []; for (let i = 0, pos = 0; i < sections.length; i += 2) { let len = sections[i], ins = sections[i + 1]; if (ins >= 0) { sections[i] = ins; sections[i + 1] = len; let index = i >> 1; while (inserted.length < index) inserted.push(Text.empty); inserted.push(len ? doc.slice(pos, pos + len) : Text.empty); } pos += len; } return new ChangeSet(sections, inserted); } /** Combine two subsequent change sets into a single set. `other` must start in the document produced by `this`. If `this` goes `docA` → `docB` and `other` represents `docB` → `docC`, the returned value will represent the change `docA` → `docC`. */ compose(other) { return this.empty ? other : other.empty ? this : composeSets(this, other, true); } /** Given another change set starting in the same document, maps this change set over the other, producing a new change set that can be applied to the document produced by applying `other`. When `before` is `true`, order changes as if `this` comes before `other`, otherwise (the default) treat `other` as coming first. Given two changes `A` and `B`, `A.compose(B.map(A))` and `B.compose(A.map(B, true))` will produce the same document. This provides a basic form of [operational transformation](https://en.wikipedia.org/wiki/Operational_transformation), and can be used for collaborative editing. */ map(other, before = false) { return other.empty ? this : mapSet(this, other, before, true); } /** Iterate over the changed ranges in the document, calling `f` for each, with the range in the original document (`fromA`-`toA`) and the range that replaces it in the new document (`fromB`-`toB`). When `individual` is true, adjacent changes are reported separately. */ iterChanges(f, individual = false) { iterChanges(this, f, individual); } /** Get a [change description](https://codemirror.net/6/docs/ref/#state.ChangeDesc) for this change set. */ get desc() { return ChangeDesc.create(this.sections); } /** @internal */ filter(ranges) { let resultSections = [], resultInserted = [], filteredSections = []; let iter = new SectionIter(this); done: for (let i = 0, pos = 0;;) { let next = i == ranges.length ? 1e9 : ranges[i++]; while (pos < next || pos == next && iter.len == 0) { if (iter.done) break done; let len = Math.min(iter.len, next - pos); addSection(filteredSections, len, -1); let ins = iter.ins == -1 ? -1 : iter.off == 0 ? iter.ins : 0; addSection(resultSections, len, ins); if (ins > 0) addInsert(resultInserted, resultSections, iter.text); iter.forward(len); pos += len; } let end = ranges[i++]; while (pos < end) { if (iter.done) break done; let len = Math.min(iter.len, end - pos); addSection(resultSections, len, -1); addSection(filteredSections, len, iter.ins == -1 ? -1 : iter.off == 0 ? iter.ins : 0); iter.forward(len); pos += len; } } return { changes: new ChangeSet(resultSections, resultInserted), filtered: ChangeDesc.create(filteredSections) }; } /** Serialize this change set to a JSON-representable value. */ toJSON() { let parts = []; for (let i = 0; i < this.sections.length; i += 2) { let len = this.sections[i], ins = this.sections[i + 1]; if (ins < 0) parts.push(len); else if (ins == 0) parts.push([len]); else parts.push([len].concat(this.inserted[i >> 1].toJSON())); } return parts; } /** Create a change set for the given changes, for a document of the given length, using `lineSep` as line separator. */ static of(changes, length, lineSep) { let sections = [], inserted = [], pos = 0; let total = null; function flush(force = false) { if (!force && !sections.length) return; if (pos < length) addSection(sections, length - pos, -1); let set = new ChangeSet(sections, inserted); total = total ? total.compose(set.map(total)) : set; sections = []; inserted = []; pos = 0; } function process(spec) { if (Array.isArray(spec)) { for (let sub of spec) process(sub); } else if (spec instanceof ChangeSet) { if (spec.length != length) throw new RangeError(`Mismatched change set length (got ${spec.length}, expected ${length})`); flush(); total = total ? total.compose(spec.map(total)) : spec; } else { let { from, to = from, insert } = spec; if (from > to || from < 0 || to > length) throw new RangeError(`Invalid change range ${from} to ${to} (in doc of length ${length})`); let insText = !insert ? Text.empty : typeof insert == "string" ? Text.of(insert.split(lineSep || DefaultSplit)) : insert; let insLen = insText.length; if (from == to && insLen == 0) return; if (from < pos) flush(); if (from > pos) addSection(sections, from - pos, -1); addSection(sections, to - from, insLen); addInsert(inserted, sections, insText); pos = to; } } process(changes); flush(!total); return total; } /** Create an empty changeset of the given length. */ static empty(length) { return new ChangeSet(length ? [length, -1] : [], []); } /** Create a changeset from its JSON representation (as produced by [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeSet.toJSON). */ static fromJSON(json) { if (!Array.isArray(json)) throw new RangeError("Invalid JSON representation of ChangeSet"); let sections = [], inserted = []; for (let i = 0; i < json.length; i++) { let part = json[i]; if (typeof part == "number") { sections.push(part, -1); } else if (!Array.isArray(part) || typeof part[0] != "number" || part.some((e, i) => i && typeof e != "string")) { throw new RangeError("Invalid JSON representation of ChangeSet"); } else if (part.length == 1) { sections.push(part[0], 0); } else { while (inserted.length < i) inserted.push(Text.empty); inserted[i] = Text.of(part.slice(1)); sections.push(part[0], inserted[i].length); } } return new ChangeSet(sections, inserted); } /** @internal */ static createSet(sections, inserted) { return new ChangeSet(sections, inserted); } } function addSection(sections, len, ins, forceJoin = false) { if (len == 0 && ins <= 0) return; let last = sections.length - 2; if (last >= 0 && ins <= 0 && ins == sections[last + 1]) sections[last] += len; else if (len == 0 && sections[last] == 0) sections[last + 1] += ins; else if (forceJoin) { sections[last] += len; sections[last + 1] += ins; } else sections.push(len, ins); } function addInsert(values, sections, value) { if (value.length == 0) return; let index = (sections.length - 2) >> 1; if (index < values.length) { values[values.length - 1] = values[values.length - 1].append(value); } else { while (values.length < index) values.push(Text.empty); values.push(value); } } function iterChanges(desc, f, individual) { let inserted = desc.inserted; for (let posA = 0, posB = 0, i = 0; i < desc.sections.length;) { let len = desc.sections[i++], ins = desc.sections[i++]; if (ins < 0) { posA += len; posB += len; } else { let endA = posA, endB = posB, text = Text.empty; for (;;) { endA += len; endB += ins; if (ins && inserted) text = text.append(inserted[(i - 2) >> 1]); if (individual || i == desc.sections.length || desc.sections[i + 1] < 0) break; len = desc.sections[i++]; ins = desc.sections[i++]; } f(posA, endA, posB, endB, text); posA = endA; posB = endB; } } } function mapSet(setA, setB, before, mkSet = false) { // Produce a copy of setA that applies to the document after setB // has been applied (assuming both start at the same document). let sections = [], insert = mkSet ? [] : null; let a = new SectionIter(setA), b = new SectionIter(setB); // Iterate over both sets in parallel. inserted tracks, for changes // in A that have to be processed piece-by-piece, whether their // content has been inserted already, and refers to the section // index. for (let inserted = -1;;) { if (a.ins == -1 && b.ins == -1) { // Move across ranges skipped by both sets. let len = Math.min(a.len, b.len); addSection(sections, len, -1); a.forward(len); b.forward(len); } else if (b.ins >= 0 && (a.ins < 0 || inserted == a.i || a.off == 0 && (b.len < a.len || b.len == a.len && !before))) { // If there's a change in B that comes before the next change in // A (ordered by start pos, then len, then before flag), skip // that (and process any changes in A it covers). let len = b.len; addSection(sections, b.ins, -1); while (len) { let piece = Math.min(a.len, len); if (a.ins >= 0 && inserted < a.i && a.len <= piece) { addSection(sections, 0, a.ins); if (insert) addInsert(insert, sections, a.text); inserted = a.i; } a.forward(piece); len -= piece; } b.next(); } else if (a.ins >= 0) { // Process the part of a change in A up to the start of the next // non-deletion change in B (if overlapping). let len = 0, left = a.len; while (left) { if (b.ins == -1) { let piece = Math.min(left, b.len); len += piece; left -= piece; b.forward(piece); } else if (b.ins == 0 && b.len < left) { left -= b.len; b.next(); } else { break; } } addSection(sections, len, inserted < a.i ? a.ins : 0); if (insert && inserted < a.i) addInsert(insert, sections, a.text); inserted = a.i; a.forward(a.len - left); } else if (a.done && b.done) { return insert ? ChangeSet.createSet(sections, insert) : ChangeDesc.create(sections); } else { throw new Error("Mismatched change set lengths"); } } } function composeSets(setA, setB, mkSet = false) { let sections = []; let insert = mkSet ? [] : null; let a = new SectionIter(setA), b = new SectionIter(setB); for (let open = false;;) { if (a.done && b.done) { return insert ? ChangeSet.createSet(sections, insert) : ChangeDesc.create(sections); } else if (a.ins == 0) { // Deletion in A addSection(sections, a.len, 0, open); a.next(); } else if (b.len == 0 && !b.done) { // Insertion in B addSection(sections, 0, b.ins, open); if (insert) addInsert(insert, sections, b.text); b.next(); } else if (a.done || b.done) { throw new Error("Mismatched change set lengths"); } else { let len = Math.min(a.len2, b.len), sectionLen = sections.length; if (a.ins == -1) { let insB = b.ins == -1 ? -1 : b.off ? 0 : b.ins; addSection(sections, len, insB, open); if (insert && insB) addInsert(insert, sections, b.text); } else if (b.ins == -1) { addSection(sections, a.off ? 0 : a.len, len, open); if (insert) addInsert(insert, sections, a.textBit(len)); } else { addSection(sections, a.off ? 0 : a.len, b.off ? 0 : b.ins, open); if (insert && !b.off) addInsert(insert, sections, b.text); } open = (a.ins > len || b.ins >= 0 && b.len > len) && (open || sections.length > sectionLen); a.forward2(len); b.forward(len); } } } class SectionIter { constructor(set) { this.set = set; this.i = 0; this.next(); } next() { let { sections } = this.set; if (this.i < sections.length) { this.len = sections[this.i++]; this.ins = sections[this.i++]; } else { this.len = 0; this.ins = -2; } this.off = 0; } get done() { return this.ins == -2; } get len2() { return this.ins < 0 ? this.len : this.ins; } get text() { let { inserted } = this.set, index = (this.i - 2) >> 1; return index >= inserted.length ? Text.empty : inserted[index]; } textBit(len) { let { inserted } = this.set, index = (this.i - 2) >> 1; return index >= inserted.length && !len ? Text.empty : inserted[index].slice(this.off, len == null ? undefined : this.off + len); } forward(len) { if (len == this.len) this.next(); else { this.len -= len; this.off += len; } } forward2(len) { if (this.ins == -1) this.forward(len); else if (len == this.ins) this.next(); else { this.ins -= len; this.off += len; } } } /** A single selection range. When [`allowMultipleSelections`](https://codemirror.net/6/docs/ref/#state.EditorState^allowMultipleSelections) is enabled, a [selection](https://codemirror.net/6/docs/ref/#state.EditorSelection) may hold multiple ranges. By default, selections hold exactly one range. */ class SelectionRange { constructor( /** The lower boundary of the range. */ from, /** The upper boundary of the range. */ to, flags) { this.from = from; this.to = to; this.flags = flags; } /** The anchor of the range—the side that doesn't move when you extend it. */ get anchor() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.to : this.from; } /** The head of the range, which is moved when the range is [extended](https://codemirror.net/6/docs/ref/#state.SelectionRange.extend). */ get head() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.from : this.to; } /** True when `anchor` and `head` are at the same position. */ get empty() { return this.from == this.to; } /** If this is a cursor that is explicitly associated with the character on one of its sides, this returns the side. -1 means the character before its position, 1 the character after, and 0 means no association. */ get assoc() { return this.flags & 4 /* RangeFlag.AssocBefore */ ? -1 : this.flags & 8 /* RangeFlag.AssocAfter */ ? 1 : 0; } /** The bidirectional text level associated with this cursor, if any. */ get bidiLevel() { let level = this.flags & 3 /* RangeFlag.BidiLevelMask */; return level == 3 ? null : level; } /** The goal column (stored vertical offset) associated with a cursor. This is used to preserve the vertical position when [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across lines of different length. */ get goalColumn() { let value = this.flags >> 5 /* RangeFlag.GoalColumnOffset */; return value == 33554431 /* RangeFlag.NoGoalColumn */ ? undefined : value; } /** Map this range through a change, producing a valid range in the updated document. */ map(change, assoc = -1) { let from, to; if (this.empty) { from = to = change.mapPos(this.from, assoc); } else { from = change.mapPos(this.from, 1); to = change.mapPos(this.to, -1); } return from == this.from && to == this.to ? this : new SelectionRange(from, to, this.flags); } /** Extend this range to cover at least `from` to `to`. */ extend(from, to = from) { if (from <= this.anchor && to >= this.anchor) return EditorSelection.range(from, to); let head = Math.abs(from - this.anchor) > Math.abs(to - this.anchor) ? from : to; return EditorSelection.range(this.anchor, head); } /** Compare this range to another range. */ eq(other) { return this.anchor == other.anchor && this.head == other.head; } /** Return a JSON-serializable object representing the range. */ toJSON() { return { anchor: this.anchor, head: this.head }; } /** Convert a JSON representation of a range to a `SelectionRange` instance. */ static fromJSON(json) { if (!json || typeof json.anchor != "number" || typeof json.head != "number") throw new RangeError("Invalid JSON representation for SelectionRange"); return EditorSelection.range(json.anchor, json.head); } /** @internal */ static create(from, to, flags) { return new SelectionRange(from, to, flags); } } /** An editor selection holds one or more selection ranges. */ class EditorSelection { constructor( /** The ranges in the selection, sorted by position. Ranges cannot overlap (but they may touch, if they aren't empty). */ ranges, /** The index of the _main_ range in the selection (which is usually the range that was added last). */ mainIndex) { this.ranges = ranges; this.mainIndex = mainIndex; } /** Map a selection through a change. Used to adjust the selection position for changes. */ map(change, assoc = -1) { if (change.empty) return this; return EditorSelection.create(this.ranges.map(r => r.map(change, assoc)), this.mainIndex); } /** Compare this selection to another selection. */ eq(other) { if (this.ranges.length != other.ranges.length || this.mainIndex != other.mainIndex) return false; for (let i = 0; i < this.ranges.length; i++) if (!this.ranges[i].eq(other.ranges[i])) return false; return true; } /** Get the primary selection range. Usually, you should make sure your code applies to _all_ ranges, by using methods like [`changeByRange`](https://codemirror.net/6/docs/ref/#state.EditorState.changeByRange). */ get main() { return this.ranges[this.mainIndex]; } /** Make sure the selection only has one range. Returns a selection holding only the main range from this selection. */ asSingle() { return this.ranges.length == 1 ? this : new EditorSelection([this.main], 0); } /** Extend this selection with an extra range. */ addRange(range, main = true) { return EditorSelection.create([range].concat(this.ranges), main ? 0 : this.mainIndex + 1); } /** Replace a given range with another range, and then normalize the selection to merge and sort ranges if necessary. */ replaceRange(range, which = this.mainIndex) { let ranges = this.ranges.slice(); ranges[which] = range; return EditorSelection.create(ranges, this.mainIndex); } /** Convert this selection to an object that can be serialized to JSON. */ toJSON() { return { ranges: this.ranges.map(r => r.toJSON()), main: this.mainIndex }; } /** Create a selection from a JSON representation. */ static fromJSON(json) { if (!json || !Array.isArray(json.ranges) || typeof json.main != "number" || json.main >= json.ranges.length) throw new RangeError("Invalid JSON representation for EditorSelection"); return new EditorSelection(json.ranges.map((r) => SelectionRange.fromJSON(r)), json.main); } /** Create a selection holding a single range. */ static single(anchor, head = anchor) { return new EditorSelection([EditorSelection.range(anchor, head)], 0); } /** Sort and merge the given set of ranges, creating a valid selection. */ static create(ranges, mainIndex = 0) { if (ranges.length == 0) throw new RangeError("A selection needs at least one range"); for (let pos = 0, i = 0; i < ranges.length; i++) { let range = ranges[i]; if (range.empty ? range.from <= pos : range.from < pos) return EditorSelection.normalized(ranges.slice(), mainIndex); pos = range.to; } return new EditorSelection(ranges, mainIndex); } /** Create a cursor selection range at the given position. You can safely ignore the optional arguments in most situations. */ static cursor(pos, assoc = 0, bidiLevel, goalColumn) { return SelectionRange.create(pos, pos, (assoc == 0 ? 0 : assoc < 0 ? 4 /* RangeFlag.AssocBefore */ : 8 /* RangeFlag.AssocAfter */) | (bidiLevel == null ? 3 : Math.min(2, bidiLevel)) | ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */)); } /** Create a selection range. */ static range(anchor, head, goalColumn) { let goal = (goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */; return head < anchor ? SelectionRange.create(head, anchor, 16 /* RangeFlag.Inverted */ | goal | 8 /* RangeFlag.AssocAfter */) : SelectionRange.create(anchor, head, goal | (head > anchor ? 4 /* RangeFlag.AssocBefore */ : 0)); } /** @internal */ static normalized(ranges, mainIndex = 0) { let main = ranges[mainIndex]; ranges.sort((a, b) => a.from - b.from); mainIndex = ranges.indexOf(main); for (let i = 1; i < ranges.length; i++) { let range = ranges[i], prev = ranges[i - 1]; if (range.empty ? range.from <= prev.to : range.from < prev.to) { let from = prev.from, to = Math.max(range.to, prev.to); if (i <= mainIndex) mainIndex--; ranges.splice(--i, 2, range.anchor > range.head ? EditorSelection.range(to, from) : EditorSelection.range(from, to)); } } return new EditorSelection(ranges, mainIndex); } } function checkSelection(selection, docLength) { for (let range of selection.ranges) if (range.to > docLength) throw new RangeError("Selection points outside of document"); } let nextID = 0; /** A facet is a labeled value that is associated with an editor state. It takes inputs from any number of extensions, and combines those into a single output value. Examples of uses of facets are the [tab size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener). */ class Facet { constructor( /** @internal */ combine, /** @internal */ compareInput, /** @internal */ compare, isStatic, enables) { this.combine = combine; this.compareInput = compareInput; this.compare = compare; this.isStatic = isStatic; /** @internal */ this.id = nextID++; this.default = combine([]); this.extensions = typeof enables == "function" ? enables(this) : enables; } /** Define a new facet. */ static define(config = {}) { return new Facet(config.combine || ((a) => a), config.compareInput || ((a, b) => a === b), config.compare || (!config.combine ? sameArray$1 : (a, b) => a === b), !!config.static, config.enables); } /** Returns an extension that adds the given value to this facet. */ of(value) { return new FacetProvider([], this, 0 /* Provider.Static */, value); } /** Create an extension that computes a value for the facet from a state. You must take care to declare the parts of the state that this value depends on, since your function is only called again for a new state when one of those parts changed. In cases where your value depends only on a single field, you'll want to use the [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method instead. */ compute(deps, get) { if (this.isStatic) throw new Error("Can't compute a static facet"); return new FacetProvider(deps, this, 1 /* Provider.Single */, get); } /** Create an extension that computes zero or more values for this facet from a state. */ computeN(deps, get) { if (this.isStatic) throw new Error("Can't compute a static facet"); return new FacetProvider(deps, this, 2 /* Provider.Multi */, get); } from(field, get) { if (!get) get = x => x; return this.compute([field], state => get(state.field(field))); } } function sameArray$1(a, b) { return a == b || a.length == b.length && a.every((e, i) => e === b[i]); } class FacetProvider { constructor(dependencies, facet, type, value) { this.dependencies = dependencies; this.facet = facet; this.type = type; this.value = value; this.id = nextID++; } dynamicSlot(addresses) { var _a; let getter = this.value; let compare = this.facet.compareInput; let id = this.id, idx = addresses[id] >> 1, multi = this.type == 2 /* Provider.Multi */; let depDoc = false, depSel = false, depAddrs = []; for (let dep of this.dependencies) { if (dep == "doc") depDoc = true; else if (dep == "selection") depSel = true; else if ((((_a = addresses[dep.id]) !== null && _a !== void 0 ? _a : 1) & 1) == 0) depAddrs.push(addresses[dep.id]); } return { create(state) { state.values[idx] = getter(state); return 1 /* SlotStatus.Changed */; }, update(state, tr) { if ((depDoc && tr.docChanged) || (depSel && (tr.docChanged || tr.selection)) || ensureAll(state, depAddrs)) { let newVal = getter(state); if (multi ? !compareArray(newVal, state.values[idx], compare) : !compare(newVal, state.values[idx])) { state.values[idx] = newVal; return 1 /* SlotStatus.Changed */; } } return 0; }, reconfigure: (state, oldState) => { let newVal = getter(state); let oldAddr = oldState.config.address[id]; if (oldAddr != null) { let oldVal = getAddr(oldState, oldAddr); if (this.dependencies.every(dep => { return dep instanceof Facet ? oldState.facet(dep) === state.facet(dep) : dep instanceof StateField ? oldState.field(dep, false) == state.field(dep, false) : true; }) || (multi ? compareArray(newVal, oldVal, compare) : compare(newVal, oldVal))) { state.values[idx] = oldVal; return 0; } } state.values[idx] = newVal; return 1 /* SlotStatus.Changed */; } }; } } function compareArray(a, b, compare) { if (a.length != b.length) return false; for (let i = 0; i < a.length; i++) if (!compare(a[i], b[i])) return false; return true; } function ensureAll(state, addrs) { let changed = false; for (let addr of addrs) if (ensureAddr(state, addr) & 1 /* SlotStatus.Changed */) changed = true; return changed; } function dynamicFacetSlot(addresses, facet, providers) { let providerAddrs = providers.map(p => addresses[p.id]); let providerTypes = providers.map(p => p.type); let dynamic = providerAddrs.filter(p => !(p & 1)); let idx = addresses[facet.id] >> 1; function get(state) { let values = []; for (let i = 0; i < providerAddrs.length; i++) { let value = getAddr(state, providerAddrs[i]); if (providerTypes[i] == 2 /* Provider.Multi */) for (let val of value) values.push(val); else values.push(value); } return facet.combine(values); } return { create(state) { for (let addr of providerAddrs) ensureAddr(state, addr); state.values[idx] = get(state); return 1 /* SlotStatus.Changed */; }, update(state, tr) { if (!ensureAll(state, dynamic)) return 0; let value = get(state); if (facet.compare(value, state.values[idx])) return 0; state.values[idx] = value; return 1 /* SlotStatus.Changed */; }, reconfigure(state, oldState) { let depChanged = ensureAll(state, providerAddrs); let oldProviders = oldState.config.facets[facet.id], oldValue = oldState.facet(facet); if (oldProviders && !depChanged && sameArray$1(providers, oldProviders)) { state.values[idx] = oldValue; return 0; } let value = get(state); if (facet.compare(value, oldValue)) { state.values[idx] = oldValue; return 0; } state.values[idx] = value; return 1 /* SlotStatus.Changed */; } }; } const initField = /*@__PURE__*/Facet.define({ static: true }); /** Fields can store additional information in an editor state, and keep it in sync with the rest of the state. */ class StateField { constructor( /** @internal */ id, createF, updateF, compareF, /** @internal */ spec) { this.id = id; this.createF = createF; this.updateF = updateF; this.compareF = compareF; this.spec = spec; /** @internal */ this.provides = undefined; } /** Define a state field. */ static define(config) { let field = new StateField(nextID++, config.create, config.update, config.compare || ((a, b) => a === b), config); if (config.provide) field.provides = config.provide(field); return field; } create(state) { let init = state.facet(initField).find(i => i.field == this); return ((init === null || init === void 0 ? void 0 : init.create) || this.createF)(state); } /** @internal */ slot(addresses) { let idx = addresses[this.id] >> 1; return { create: (state) => { state.values[idx] = this.create(state); return 1 /* SlotStatus.Changed */; }, update: (state, tr) => { let oldVal = state.values[idx]; let value = this.updateF(oldVal, tr); if (this.compareF(oldVal, value)) return 0; state.values[idx] = value; return 1 /* SlotStatus.Changed */; }, reconfigure: (state, oldState) => { if (oldState.config.address[this.id] != null) { state.values[idx] = oldState.field(this); return 0; } state.values[idx] = this.create(state); return 1 /* SlotStatus.Changed */; } }; } /** Returns an extension that enables this field and overrides the way it is initialized. Can be useful when you need to provide a non-default starting value for the field. */ init(create) { return [this, initField.of({ field: this, create })]; } /** State field instances can be used as [`Extension`](https://codemirror.net/6/docs/ref/#state.Extension) values to enable the field in a given state. */ get extension() { return this; } } const Prec_ = { lowest: 4, low: 3, default: 2, high: 1, highest: 0 }; function prec(value) { return (ext) => new PrecExtension(ext, value); } /** By default extensions are registered in the order they are found in the flattened form of nested array that was provided. Individual extension values can be assigned a precedence to override this. Extensions that do not have a precedence set get the precedence of the nearest parent with a precedence, or [`default`](https://codemirror.net/6/docs/ref/#state.Prec.default) if there is no such parent. The final ordering of extensions is determined by first sorting by precedence and then by order within each precedence. */ const Prec = { /** The highest precedence level, for extensions that should end up near the start of the precedence ordering. */ highest: /*@__PURE__*/prec(Prec_.highest), /** A higher-than-default precedence, for extensions that should come before those with default precedence. */ high: /*@__PURE__*/prec(Prec_.high), /** The default precedence, which is also used for extensions without an explicit precedence. */ default: /*@__PURE__*/prec(Prec_.default), /** A lower-than-default precedence. */ low: /*@__PURE__*/prec(Prec_.low), /** The lowest precedence level. Meant for things that should end up near the end of the extension order. */ lowest: /*@__PURE__*/prec(Prec_.lowest) }; class PrecExtension { constructor(inner, prec) { this.inner = inner; this.prec = prec; } } /** Extension compartments can be used to make a configuration dynamic. By [wrapping](https://codemirror.net/6/docs/ref/#state.Compartment.of) part of your configuration in a compartment, you can later [replace](https://codemirror.net/6/docs/ref/#state.Compartment.reconfigure) that part through a transaction. */ class Compartment { /** Create an instance of this compartment to add to your [state configuration](https://codemirror.net/6/docs/ref/#state.EditorStateConfig.extensions). */ of(ext) { return new CompartmentInstance(this, ext); } /** Create an [effect](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) that reconfigures this compartment. */ reconfigure(content) { return Compartment.reconfigure.of({ compartment: this, extension: content }); } /** Get the current content of the compartment in the state, or `undefined` if it isn't present. */ get(state) { return state.config.compartments.get(this); } } class CompartmentInstance { constructor(compartment, inner) { this.compartment = compartment; this.inner = inner; } } class Configuration { constructor(base, compartments, dynamicSlots, address, staticValues, facets) { this.base = base; this.compartments = compartments; this.dynamicSlots = dynamicSlots; this.address = address; this.staticValues = staticValues; this.facets = facets; this.statusTemplate = []; while (this.statusTemplate.length < dynamicSlots.length) this.statusTemplate.push(0 /* SlotStatus.Unresolved */); } staticFacet(facet) { let addr = this.address[facet.id]; return addr == null ? facet.default : this.staticValues[addr >> 1]; } static resolve(base, compartments, oldState) { let fields = []; let facets = Object.create(null); let newCompartments = new Map(); for (let ext of flatten(base, compartments, newCompartments)) { if (ext instanceof StateField) fields.push(ext); else (facets[ext.facet.id] || (facets[ext.facet.id] = [])).push(ext); } let address = Object.create(null); let staticValues = []; let dynamicSlots = []; for (let field of fields) { address[field.id] = dynamicSlots.length << 1; dynamicSlots.push(a => field.slot(a)); } let oldFacets = oldState === null || oldState === void 0 ? void 0 : oldState.config.facets; for (let id in facets) { let providers = facets[id], facet = providers[0].facet; let oldProviders = oldFacets && oldFacets[id] || []; if (providers.every(p => p.type == 0 /* Provider.Static */)) { address[facet.id] = (staticValues.length << 1) | 1; if (sameArray$1(oldProviders, providers)) { staticValues.push(oldState.facet(facet)); } else { let value = facet.combine(providers.map(p => p.value)); staticValues.push(oldState && facet.compare(value, oldState.facet(facet)) ? oldState.facet(facet) : value); } } else { for (let p of providers) { if (p.type == 0 /* Provider.Static */) { address[p.id] = (staticValues.length << 1) | 1; staticValues.push(p.value); } else { address[p.id] = dynamicSlots.length << 1; dynamicSlots.push(a => p.dynamicSlot(a)); } } address[facet.id] = dynamicSlots.length << 1; dynamicSlots.push(a => dynamicFacetSlot(a, facet, providers)); } } let dynamic = dynamicSlots.map(f => f(address)); return new Configuration(base, newCompartments, dynamic, address, staticValues, facets); } } function flatten(extension, compartments, newCompartments) { let result = [[], [], [], [], []]; let seen = new Map(); function inner(ext, prec) { let known = seen.get(ext); if (known != null) { if (known <= prec) return; let found = result[known].indexOf(ext); if (found > -1) result[known].splice(found, 1); if (ext instanceof CompartmentInstance) newCompartments.delete(ext.compartment); } seen.set(ext, prec); if (Array.isArray(ext)) { for (let e of ext) inner(e, prec); } else if (ext instanceof CompartmentInstance) { if (newCompartments.has(ext.compartment)) throw new RangeError(`Duplicate use of compartment in extensions`); let content = compartments.get(ext.compartment) || ext.inner; newCompartments.set(ext.compartment, content); inner(content, prec); } else if (ext instanceof PrecExtension) { inner(ext.inner, ext.prec); } else if (ext instanceof StateField) { result[prec].push(ext); if (ext.provides) inner(ext.provides, prec); } else if (ext instanceof FacetProvider) { result[prec].push(ext); if (ext.facet.extensions) inner(ext.facet.extensions, Prec_.default); } else { let content = ext.extension; if (!content) throw new Error(`Unrecognized extension value in extension set (${ext}). This sometimes happens because multiple instances of @codemirror/state are loaded, breaking instanceof checks.`); inner(content, prec); } } inner(extension, Prec_.default); return result.reduce((a, b) => a.concat(b)); } function ensureAddr(state, addr) { if (addr & 1) return 2 /* SlotStatus.Computed */; let idx = addr >> 1; let status = state.status[idx]; if (status == 4 /* SlotStatus.Computing */) throw new Error("Cyclic dependency between fields and/or facets"); if (status & 2 /* SlotStatus.Computed */) return status; state.status[idx] = 4 /* SlotStatus.Computing */; let changed = state.computeSlot(state, state.config.dynamicSlots[idx]); return state.status[idx] = 2 /* SlotStatus.Computed */ | changed; } function getAddr(state, addr) { return addr & 1 ? state.config.staticValues[addr >> 1] : state.values[addr >> 1]; } const languageData = /*@__PURE__*/Facet.define(); const allowMultipleSelections = /*@__PURE__*/Facet.define({ combine: values => values.some(v => v), static: true }); const lineSeparator = /*@__PURE__*/Facet.define({ combine: values => values.length ? values[0] : undefined, static: true }); const changeFilter = /*@__PURE__*/Facet.define(); const transactionFilter = /*@__PURE__*/Facet.define(); const transactionExtender = /*@__PURE__*/Facet.define(); const readOnly = /*@__PURE__*/Facet.define({ combine: values => values.length ? values[0] : false }); /** Annotations are tagged values that are used to add metadata to transactions in an extensible way. They should be used to model things that effect the entire transaction (such as its [time stamp](https://codemirror.net/6/docs/ref/#state.Transaction^time) or information about its [origin](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent)). For effects that happen _alongside_ the other changes made by the transaction, [state effects](https://codemirror.net/6/docs/ref/#state.StateEffect) are more appropriate. */ class Annotation { /** @internal */ constructor( /** The annotation type. */ type, /** The value of this annotation. */ value) { this.type = type; this.value = value; } /** Define a new type of annotation. */ static define() { return new AnnotationType(); } } /** Marker that identifies a type of [annotation](https://codemirror.net/6/docs/ref/#state.Annotation). */ class AnnotationType { /** Create an instance of this annotation. */ of(value) { return new Annotation(this, value); } } /** Representation of a type of state effect. Defined with [`StateEffect.define`](https://codemirror.net/6/docs/ref/#state.StateEffect^define). */ class StateEffectType { /** @internal */ constructor( // The `any` types in these function types are there to work // around TypeScript issue #37631, where the type guard on // `StateEffect.is` mysteriously stops working when these properly // have type `Value`. /** @internal */ map) { this.map = map; } /** Create a [state effect](https://codemirror.net/6/docs/ref/#state.StateEffect) instance of this type. */ of(value) { return new StateEffect(this, value); } } /** State effects can be used to represent additional effects associated with a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction.effects). They are often useful to model changes to custom [state fields](https://codemirror.net/6/docs/ref/#state.StateField), when those changes aren't implicit in document or selection changes. */ class StateEffect { /** @internal */ constructor( /** @internal */ type, /** The value of this effect. */ value) { this.type = type; this.value = value; } /** Map this effect through a position mapping. Will return `undefined` when that ends up deleting the effect. */ map(mapping) { let mapped = this.type.map(this.value, mapping); return mapped === undefined ? undefined : mapped == this.value ? this : new StateEffect(this.type, mapped); } /** Tells you whether this effect object is of a given [type](https://codemirror.net/6/docs/ref/#state.StateEffectType). */ is(type) { return this.type == type; } /** Define a new effect type. The type parameter indicates the type of values that his effect holds. */ static define(spec = {}) { return new StateEffectType(spec.map || (v => v)); } /** Map an array of effects through a change set. */ static mapEffects(effects, mapping) { if (!effects.length) return effects; let result = []; for (let effect of effects) { let mapped = effect.map(mapping); if (mapped) result.push(mapped); } return result; } } /** This effect can be used to reconfigure the root extensions of the editor. Doing this will discard any extensions [appended](https://codemirror.net/6/docs/ref/#state.StateEffect^appendConfig), but does not reset the content of [reconfigured](https://codemirror.net/6/docs/ref/#state.Compartment.reconfigure) compartments. */ StateEffect.reconfigure = /*@__PURE__*/StateEffect.define(); /** Append extensions to the top-level configuration of the editor. */ StateEffect.appendConfig = /*@__PURE__*/StateEffect.define(); /** Changes to the editor state are grouped into transactions. Typically, a user action creates a single transaction, which may contain any number of document changes, may change the selection, or have other effects. Create a transaction by calling [`EditorState.update`](https://codemirror.net/6/docs/ref/#state.EditorState.update), or immediately dispatch one by calling [`EditorView.dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch). */ class Transaction { constructor( /** The state from which the transaction starts. */ startState, /** The document changes made by this transaction. */ changes, /** The selection set by this transaction, or undefined if it doesn't explicitly set a selection. */ selection, /** The effects added to the transaction. */ effects, /** @internal */ annotations, /** Whether the selection should be scrolled into view after this transaction is dispatched. */ scrollIntoView) { this.startState = startState; this.changes = changes; this.selection = selection; this.effects = effects; this.annotations = annotations; this.scrollIntoView = scrollIntoView; /** @internal */ this._doc = null; /** @internal */ this._state = null; if (selection) checkSelection(selection, changes.newLength); if (!annotations.some((a) => a.type == Transaction.time)) this.annotations = annotations.concat(Transaction.time.of(Date.now())); } /** @internal */ static create(startState, changes, selection, effects, annotations, scrollIntoView) { return new Transaction(startState, changes, selection, effects, annotations, scrollIntoView); } /** The new document produced by the transaction. Contrary to [`.state`](https://codemirror.net/6/docs/ref/#state.Transaction.state)`.doc`, accessing this won't force the entire new state to be computed right away, so it is recommended that [transaction filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter) use this getter when they need to look at the new document. */ get newDoc() { return this._doc || (this._doc = this.changes.apply(this.startState.doc)); } /** The new selection produced by the transaction. If [`this.selection`](https://codemirror.net/6/docs/ref/#state.Transaction.selection) is undefined, this will [map](https://codemirror.net/6/docs/ref/#state.EditorSelection.map) the start state's current selection through the changes made by the transaction. */ get newSelection() { return this.selection || this.startState.selection.map(this.changes); } /** The new state created by the transaction. Computed on demand (but retained for subsequent access), so it is recommended not to access it in [transaction filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter) when possible. */ get state() { if (!this._state) this.startState.applyTransaction(this); return this._state; } /** Get the value of the given annotation type, if any. */ annotation(type) { for (let ann of this.annotations) if (ann.type == type) return ann.value; return undefined; } /** Indicates whether the transaction changed the document. */ get docChanged() { return !this.changes.empty; } /** Indicates whether this transaction reconfigures the state (through a [configuration compartment](https://codemirror.net/6/docs/ref/#state.Compartment) or with a top-level configuration [effect](https://codemirror.net/6/docs/ref/#state.StateEffect^reconfigure). */ get reconfigured() { return this.startState.config != this.state.config; } /** Returns true if the transaction has a [user event](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent) annotation that is equal to or more specific than `event`. For example, if the transaction has `"select.pointer"` as user event, `"select"` and `"select.pointer"` will match it. */ isUserEvent(event) { let e = this.annotation(Transaction.userEvent); return !!(e && (e == event || e.length > event.length && e.slice(0, event.length) == event && e[event.length] == ".")); } } /** Annotation used to store transaction timestamps. Automatically added to every transaction, holding `Date.now()`. */ Transaction.time = /*@__PURE__*/Annotation.define(); /** Annotation used to associate a transaction with a user interface event. Holds a string identifying the event, using a dot-separated format to support attaching more specific information. The events used by the core libraries are: - `"input"` when content is entered - `"input.type"` for typed input - `"input.type.compose"` for composition - `"input.paste"` for pasted input - `"input.drop"` when adding content with drag-and-drop - `"input.complete"` when autocompleting - `"delete"` when the user deletes content - `"delete.selection"` when deleting the selection - `"delete.forward"` when deleting forward from the selection - `"delete.backward"` when deleting backward from the selection - `"delete.cut"` when cutting to the clipboard - `"move"` when content is moved - `"move.drop"` when content is moved within the editor through drag-and-drop - `"select"` when explicitly changing the selection - `"select.pointer"` when selecting with a mouse or other pointing device - `"undo"` and `"redo"` for history actions Use [`isUserEvent`](https://codemirror.net/6/docs/ref/#state.Transaction.isUserEvent) to check whether the annotation matches a given event. */ Transaction.userEvent = /*@__PURE__*/Annotation.define(); /** Annotation indicating whether a transaction should be added to the undo history or not. */ Transaction.addToHistory = /*@__PURE__*/Annotation.define(); /** Annotation indicating (when present and true) that a transaction represents a change made by some other actor, not the user. This is used, for example, to tag other people's changes in collaborative editing. */ Transaction.remote = /*@__PURE__*/Annotation.define(); function joinRanges(a, b) { let result = []; for (let iA = 0, iB = 0;;) { let from, to; if (iA < a.length && (iB == b.length || b[iB] >= a[iA])) { from = a[iA++]; to = a[iA++]; } else if (iB < b.length) { from = b[iB++]; to = b[iB++]; } else return result; if (!result.length || result[result.length - 1] < from) result.push(from, to); else if (result[result.length - 1] < to) result[result.length - 1] = to; } } function mergeTransaction(a, b, sequential) { var _a; let mapForA, mapForB, changes; if (sequential) { mapForA = b.changes; mapForB = ChangeSet.empty(b.changes.length); changes = a.changes.compose(b.changes); } else { mapForA = b.changes.map(a.changes); mapForB = a.changes.mapDesc(b.changes, true); changes = a.changes.compose(mapForA); } return { changes, selection: b.selection ? b.selection.map(mapForB) : (_a = a.selection) === null || _a === void 0 ? void 0 : _a.map(mapForA), effects: StateEffect.mapEffects(a.effects, mapForA).concat(StateEffect.mapEffects(b.effects, mapForB)), annotations: a.annotations.length ? a.annotations.concat(b.annotations) : b.annotations, scrollIntoView: a.scrollIntoView || b.scrollIntoView }; } function resolveTransactionInner(state, spec, docSize) { let sel = spec.selection, annotations = asArray$1(spec.annotations); if (spec.userEvent) annotations = annotations.concat(Transaction.userEvent.of(spec.userEvent)); return { changes: spec.changes instanceof ChangeSet ? spec.changes : ChangeSet.of(spec.changes || [], docSize, state.facet(lineSeparator)), selection: sel && (sel instanceof EditorSelection ? sel : EditorSelection.single(sel.anchor, sel.head)), effects: asArray$1(spec.effects), annotations, scrollIntoView: !!spec.scrollIntoView }; } function resolveTransaction(state, specs, filter) { let s = resolveTransactionInner(state, specs.length ? specs[0] : {}, state.doc.length); if (specs.length && specs[0].filter === false) filter = false; for (let i = 1; i < specs.length; i++) { if (specs[i].filter === false) filter = false; let seq = !!specs[i].sequential; s = mergeTransaction(s, resolveTransactionInner(state, specs[i], seq ? s.changes.newLength : state.doc.length), seq); } let tr = Transaction.create(state, s.changes, s.selection, s.effects, s.annotations, s.scrollIntoView); return extendTransaction(filter ? filterTransaction(tr) : tr); } // Finish a transaction by applying filters if necessary. function filterTransaction(tr) { let state = tr.startState; // Change filters let result = true; for (let filter of state.facet(changeFilter)) { let value = filter(tr); if (value === false) { result = false; break; } if (Array.isArray(value)) result = result === true ? value : joinRanges(result, value); } if (result !== true) { let changes, back; if (result === false) { back = tr.changes.invertedDesc; changes = ChangeSet.empty(state.doc.length); } else { let filtered = tr.changes.filter(result); changes = filtered.changes; back = filtered.filtered.mapDesc(filtered.changes).invertedDesc; } tr = Transaction.create(state, changes, tr.selection && tr.selection.map(back), StateEffect.mapEffects(tr.effects, back), tr.annotations, tr.scrollIntoView); } // Transaction filters let filters = state.facet(transactionFilter); for (let i = filters.length - 1; i >= 0; i--) { let filtered = filters[i](tr); if (filtered instanceof Transaction) tr = filtered; else if (Array.isArray(filtered) && filtered.length == 1 && filtered[0] instanceof Transaction) tr = filtered[0]; else tr = resolveTransaction(state, asArray$1(filtered), false); } return tr; } function extendTransaction(tr) { let state = tr.startState, extenders = state.facet(transactionExtender), spec = tr; for (let i = extenders.length - 1; i >= 0; i--) { let extension = extenders[i](tr); if (extension && Object.keys(extension).length) spec = mergeTransaction(spec, resolveTransactionInner(state, extension, tr.changes.newLength), true); } return spec == tr ? tr : Transaction.create(state, tr.changes, tr.selection, spec.effects, spec.annotations, spec.scrollIntoView); } const none$2 = []; function asArray$1(value) { return value == null ? none$2 : Array.isArray(value) ? value : [value]; } /** The categories produced by a [character categorizer](https://codemirror.net/6/docs/ref/#state.EditorState.charCategorizer). These are used do things like selecting by word. */ var CharCategory = /*@__PURE__*/(function (CharCategory) { /** Word characters. */ CharCategory[CharCategory["Word"] = 0] = "Word"; /** Whitespace. */ CharCategory[CharCategory["Space"] = 1] = "Space"; /** Anything else. */ CharCategory[CharCategory["Other"] = 2] = "Other"; return CharCategory})(CharCategory || (CharCategory = {})); const nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/; let wordChar; try { wordChar = /*@__PURE__*/new RegExp("[\\p{Alphabetic}\\p{Number}_]", "u"); } catch (_) { } function hasWordChar(str) { if (wordChar) return wordChar.test(str); for (let i = 0; i < str.length; i++) { let ch = str[i]; if (/\w/.test(ch) || ch > "\x80" && (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch))) return true; } return false; } function makeCategorizer(wordChars) { return (char) => { if (!/\S/.test(char)) return CharCategory.Space; if (hasWordChar(char)) return CharCategory.Word; for (let i = 0; i < wordChars.length; i++) if (char.indexOf(wordChars[i]) > -1) return CharCategory.Word; return CharCategory.Other; }; } /** The editor state class is a persistent (immutable) data structure. To update a state, you [create](https://codemirror.net/6/docs/ref/#state.EditorState.update) a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction), which produces a _new_ state instance, without modifying the original object. As such, _never_ mutate properties of a state directly. That'll just break things. */ class EditorState { constructor( /** @internal */ config, /** The current document. */ doc, /** The current selection. */ selection, /** @internal */ values, computeSlot, tr) { this.config = config; this.doc = doc; this.selection = selection; this.values = values; this.status = config.statusTemplate.slice(); this.computeSlot = computeSlot; // Fill in the computed state immediately, so that further queries // for it made during the update return this state if (tr) tr._state = this; for (let i = 0; i < this.config.dynamicSlots.length; i++) ensureAddr(this, i << 1); this.computeSlot = null; } field(field, require = true) { let addr = this.config.address[field.id]; if (addr == null) { if (require) throw new RangeError("Field is not present in this state"); return undefined; } ensureAddr(this, addr); return getAddr(this, addr); } /** Create a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction) that updates this state. Any number of [transaction specs](https://codemirror.net/6/docs/ref/#state.TransactionSpec) can be passed. Unless [`sequential`](https://codemirror.net/6/docs/ref/#state.TransactionSpec.sequential) is set, the [changes](https://codemirror.net/6/docs/ref/#state.TransactionSpec.changes) (if any) of each spec are assumed to start in the _current_ document (not the document produced by previous specs), and its [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) and [effects](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) are assumed to refer to the document created by its _own_ changes. The resulting transaction contains the combined effect of all the different specs. For [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection), later specs take precedence over earlier ones. */ update(...specs) { return resolveTransaction(this, specs, true); } /** @internal */ applyTransaction(tr) { let conf = this.config, { base, compartments } = conf; for (let effect of tr.effects) { if (effect.is(Compartment.reconfigure)) { if (conf) { compartments = new Map; conf.compartments.forEach((val, key) => compartments.set(key, val)); conf = null; } compartments.set(effect.value.compartment, effect.value.extension); } else if (effect.is(StateEffect.reconfigure)) { conf = null; base = effect.value; } else if (effect.is(StateEffect.appendConfig)) { conf = null; base = asArray$1(base).concat(effect.value); } } let startValues; if (!conf) { conf = Configuration.resolve(base, compartments, this); let intermediateState = new EditorState(conf, this.doc, this.selection, conf.dynamicSlots.map(() => null), (state, slot) => slot.reconfigure(state, this), null); startValues = intermediateState.values; } else { startValues = tr.startState.values.slice(); } new EditorState(conf, tr.newDoc, tr.newSelection, startValues, (state, slot) => slot.update(state, tr), tr); } /** Create a [transaction spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec) that replaces every selection range with the given content. */ replaceSelection(text) { if (typeof text == "string") text = this.toText(text); return this.changeByRange(range => ({ changes: { from: range.from, to: range.to, insert: text }, range: EditorSelection.cursor(range.from + text.length) })); } /** Create a set of changes and a new selection by running the given function for each range in the active selection. The function can return an optional set of changes (in the coordinate space of the start document), plus an updated range (in the coordinate space of the document produced by the call's own changes). This method will merge all the changes and ranges into a single changeset and selection, and return it as a [transaction spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec), which can be passed to [`update`](https://codemirror.net/6/docs/ref/#state.EditorState.update). */ changeByRange(f) { let sel = this.selection; let result1 = f(sel.ranges[0]); let changes = this.changes(result1.changes), ranges = [result1.range]; let effects = asArray$1(result1.effects); for (let i = 1; i < sel.ranges.length; i++) { let result = f(sel.ranges[i]); let newChanges = this.changes(result.changes), newMapped = newChanges.map(changes); for (let j = 0; j < i; j++) ranges[j] = ranges[j].map(newMapped); let mapBy = changes.mapDesc(newChanges, true); ranges.push(result.range.map(mapBy)); changes = changes.compose(newMapped); effects = StateEffect.mapEffects(effects, newMapped).concat(StateEffect.mapEffects(asArray$1(result.effects), mapBy)); } return { changes, selection: EditorSelection.create(ranges, sel.mainIndex), effects }; } /** Create a [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet) from the given change description, taking the state's document length and line separator into account. */ changes(spec = []) { if (spec instanceof ChangeSet) return spec; return ChangeSet.of(spec, this.doc.length, this.facet(EditorState.lineSeparator)); } /** Using the state's [line separator](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator), create a [`Text`](https://codemirror.net/6/docs/ref/#state.Text) instance from the given string. */ toText(string) { return Text.of(string.split(this.facet(EditorState.lineSeparator) || DefaultSplit)); } /** Return the given range of the document as a string. */ sliceDoc(from = 0, to = this.doc.length) { return this.doc.sliceString(from, to, this.lineBreak); } /** Get the value of a state [facet](https://codemirror.net/6/docs/ref/#state.Facet). */ facet(facet) { let addr = this.config.address[facet.id]; if (addr == null) return facet.default; ensureAddr(this, addr); return getAddr(this, addr); } /** Convert this state to a JSON-serializable object. When custom fields should be serialized, you can pass them in as an object mapping property names (in the resulting object, which should not use `doc` or `selection`) to fields. */ toJSON(fields) { let result = { doc: this.sliceDoc(), selection: this.selection.toJSON() }; if (fields) for (let prop in fields) { let value = fields[prop]; if (value instanceof StateField && this.config.address[value.id] != null) result[prop] = value.spec.toJSON(this.field(fields[prop]), this); } return result; } /** Deserialize a state from its JSON representation. When custom fields should be deserialized, pass the same object you passed to [`toJSON`](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON) when serializing as third argument. */ static fromJSON(json, config = {}, fields) { if (!json || typeof json.doc != "string") throw new RangeError("Invalid JSON representation for EditorState"); let fieldInit = []; if (fields) for (let prop in fields) { if (Object.prototype.hasOwnProperty.call(json, prop)) { let field = fields[prop], value = json[prop]; fieldInit.push(field.init(state => field.spec.fromJSON(value, state))); } } return EditorState.create({ doc: json.doc, selection: EditorSelection.fromJSON(json.selection), extensions: config.extensions ? fieldInit.concat([config.extensions]) : fieldInit }); } /** Create a new state. You'll usually only need this when initializing an editor—updated states are created by applying transactions. */ static create(config = {}) { let configuration = Configuration.resolve(config.extensions || [], new Map); let doc = config.doc instanceof Text ? config.doc : Text.of((config.doc || "").split(configuration.staticFacet(EditorState.lineSeparator) || DefaultSplit)); let selection = !config.selection ? EditorSelection.single(0) : config.selection instanceof EditorSelection ? config.selection : EditorSelection.single(config.selection.anchor, config.selection.head); checkSelection(selection, doc.length); if (!configuration.staticFacet(allowMultipleSelections)) selection = selection.asSingle(); return new EditorState(configuration, doc, selection, configuration.dynamicSlots.map(() => null), (state, slot) => slot.create(state), null); } /** The size (in columns) of a tab in the document, determined by the [`tabSize`](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) facet. */ get tabSize() { return this.facet(EditorState.tabSize); } /** Get the proper [line-break](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator) string for this state. */ get lineBreak() { return this.facet(EditorState.lineSeparator) || "\n"; } /** Returns true when the editor is [configured](https://codemirror.net/6/docs/ref/#state.EditorState^readOnly) to be read-only. */ get readOnly() { return this.facet(readOnly); } /** Look up a translation for the given phrase (via the [`phrases`](https://codemirror.net/6/docs/ref/#state.EditorState^phrases) facet), or return the original string if no translation is found. If additional arguments are passed, they will be inserted in place of markers like `$1` (for the first value) and `$2`, etc. A single `$` is equivalent to `$1`, and `$$` will produce a literal dollar sign. */ phrase(phrase, ...insert) { for (let map of this.facet(EditorState.phrases)) if (Object.prototype.hasOwnProperty.call(map, phrase)) { phrase = map[phrase]; break; } if (insert.length) phrase = phrase.replace(/\$(\$|\d*)/g, (m, i) => { if (i == "$") return "$"; let n = +(i || 1); return !n || n > insert.length ? m : insert[n - 1]; }); return phrase; } /** Find the values for a given language data field, provided by the the [`languageData`](https://codemirror.net/6/docs/ref/#state.EditorState^languageData) facet. */ languageDataAt(name, pos, side = -1) { let values = []; for (let provider of this.facet(languageData)) { for (let result of provider(this, pos, side)) { if (Object.prototype.hasOwnProperty.call(result, name)) values.push(result[name]); } } return values; } /** Return a function that can categorize strings (expected to represent a single [grapheme cluster](https://codemirror.net/6/docs/ref/#state.findClusterBreak)) into one of: - Word (contains an alphanumeric character or a character explicitly listed in the local language's `"wordChars"` language data, which should be a string) - Space (contains only whitespace) - Other (anything else) */ charCategorizer(at) { return makeCategorizer(this.languageDataAt("wordChars", at).join("")); } /** Find the word at the given position, meaning the range containing all [word](https://codemirror.net/6/docs/ref/#state.CharCategory.Word) characters around it. If no word characters are adjacent to the position, this returns null. */ wordAt(pos) { let { text, from, length } = this.doc.lineAt(pos); let cat = this.charCategorizer(pos); let start = pos - from, end = pos - from; while (start > 0) { let prev = findClusterBreak(text, start, false); if (cat(text.slice(prev, start)) != CharCategory.Word) break; start = prev; } while (end < length) { let next = findClusterBreak(text, end); if (cat(text.slice(end, next)) != CharCategory.Word) break; end = next; } return start == end ? null : EditorSelection.range(start + from, end + from); } } /** A facet that, when enabled, causes the editor to allow multiple ranges to be selected. Be careful though, because by default the editor relies on the native DOM selection, which cannot handle multiple selections. An extension like [`drawSelection`](https://codemirror.net/6/docs/ref/#view.drawSelection) can be used to make secondary selections visible to the user. */ EditorState.allowMultipleSelections = allowMultipleSelections; /** Configures the tab size to use in this state. The first (highest-precedence) value of the facet is used. If no value is given, this defaults to 4. */ EditorState.tabSize = /*@__PURE__*/Facet.define({ combine: values => values.length ? values[0] : 4 }); /** The line separator to use. By default, any of `"\n"`, `"\r\n"` and `"\r"` is treated as a separator when splitting lines, and lines are joined with `"\n"`. When you configure a value here, only that precise separator will be used, allowing you to round-trip documents through the editor without normalizing line separators. */ EditorState.lineSeparator = lineSeparator; /** This facet controls the value of the [`readOnly`](https://codemirror.net/6/docs/ref/#state.EditorState.readOnly) getter, which is consulted by commands and extensions that implement editing functionality to determine whether they should apply. It defaults to false, but when its highest-precedence value is `true`, such functionality disables itself. Not to be confused with [`EditorView.editable`](https://codemirror.net/6/docs/ref/#view.EditorView^editable), which controls whether the editor's DOM is set to be editable (and thus focusable). */ EditorState.readOnly = readOnly; /** Registers translation phrases. The [`phrase`](https://codemirror.net/6/docs/ref/#state.EditorState.phrase) method will look through all objects registered with this facet to find translations for its argument. */ EditorState.phrases = /*@__PURE__*/Facet.define({ compare(a, b) { let kA = Object.keys(a), kB = Object.keys(b); return kA.length == kB.length && kA.every(k => a[k] == b[k]); } }); /** A facet used to register [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) providers. */ EditorState.languageData = languageData; /** Facet used to register change filters, which are called for each transaction (unless explicitly [disabled](https://codemirror.net/6/docs/ref/#state.TransactionSpec.filter)), and can suppress part of the transaction's changes. Such a function can return `true` to indicate that it doesn't want to do anything, `false` to completely stop the changes in the transaction, or a set of ranges in which changes should be suppressed. Such ranges are represented as an array of numbers, with each pair of two numbers indicating the start and end of a range. So for example `[10, 20, 100, 110]` suppresses changes between 10 and 20, and between 100 and 110. */ EditorState.changeFilter = changeFilter; /** Facet used to register a hook that gets a chance to update or replace transaction specs before they are applied. This will only be applied for transactions that don't have [`filter`](https://codemirror.net/6/docs/ref/#state.TransactionSpec.filter) set to `false`. You can either return a single transaction spec (possibly the input transaction), or an array of specs (which will be combined in the same way as the arguments to [`EditorState.update`](https://codemirror.net/6/docs/ref/#state.EditorState.update)). When possible, it is recommended to avoid accessing [`Transaction.state`](https://codemirror.net/6/docs/ref/#state.Transaction.state) in a filter, since it will force creation of a state that will then be discarded again, if the transaction is actually filtered. (This functionality should be used with care. Indiscriminately modifying transaction is likely to break something or degrade the user experience.) */ EditorState.transactionFilter = transactionFilter; /** This is a more limited form of [`transactionFilter`](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter), which can only add [annotations](https://codemirror.net/6/docs/ref/#state.TransactionSpec.annotations) and [effects](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects). _But_, this type of filter runs even if the transaction has disabled regular [filtering](https://codemirror.net/6/docs/ref/#state.TransactionSpec.filter), making it suitable for effects that don't need to touch the changes or selection, but do want to process every transaction. Extenders run _after_ filters, when both are present. */ EditorState.transactionExtender = transactionExtender; Compartment.reconfigure = /*@__PURE__*/StateEffect.define(); /** Utility function for combining behaviors to fill in a config object from an array of provided configs. `defaults` should hold default values for all optional fields in `Config`. The function will, by default, error when a field gets two values that aren't `===`-equal, but you can provide combine functions per field to do something else. */ function combineConfig(configs, defaults, // Should hold only the optional properties of Config, but I haven't managed to express that combine = {}) { let result = {}; for (let config of configs) for (let key of Object.keys(config)) { let value = config[key], current = result[key]; if (current === undefined) result[key] = value; else if (current === value || value === undefined) ; // No conflict else if (Object.hasOwnProperty.call(combine, key)) result[key] = combine[key](current, value); else throw new Error("Config merge conflict for field " + key); } for (let key in defaults) if (result[key] === undefined) result[key] = defaults[key]; return result; } /** Each range is associated with a value, which must inherit from this class. */ class RangeValue { /** Compare this value with another value. Used when comparing rangesets. The default implementation compares by identity. Unless you are only creating a fixed number of unique instances of your value type, it is a good idea to implement this properly. */ eq(other) { return this == other; } /** Create a [range](https://codemirror.net/6/docs/ref/#state.Range) with this value. */ range(from, to = from) { return Range$1.create(from, to, this); } } RangeValue.prototype.startSide = RangeValue.prototype.endSide = 0; RangeValue.prototype.point = false; RangeValue.prototype.mapMode = MapMode.TrackDel; /** A range associates a value with a range of positions. */ class Range$1 { constructor( /** The range's start position. */ from, /** Its end position. */ to, /** The value associated with this range. */ value) { this.from = from; this.to = to; this.value = value; } /** @internal */ static create(from, to, value) { return new Range$1(from, to, value); } } function cmpRange(a, b) { return a.from - b.from || a.value.startSide - b.value.startSide; } class Chunk { constructor(from, to, value, // Chunks are marked with the largest point that occurs // in them (or -1 for no points), so that scans that are // only interested in points (such as the // heightmap-related logic) can skip range-only chunks. maxPoint) { this.from = from; this.to = to; this.value = value; this.maxPoint = maxPoint; } get length() { return this.to[this.to.length - 1]; } // Find the index of the given position and side. Use the ranges' // `from` pos when `end == false`, `to` when `end == true`. findIndex(pos, side, end, startAt = 0) { let arr = end ? this.to : this.from; for (let lo = startAt, hi = arr.length;;) { if (lo == hi) return lo; let mid = (lo + hi) >> 1; let diff = arr[mid] - pos || (end ? this.value[mid].endSide : this.value[mid].startSide) - side; if (mid == lo) return diff >= 0 ? lo : hi; if (diff >= 0) hi = mid; else lo = mid + 1; } } between(offset, from, to, f) { for (let i = this.findIndex(from, -1000000000 /* C.Far */, true), e = this.findIndex(to, 1000000000 /* C.Far */, false, i); i < e; i++) if (f(this.from[i] + offset, this.to[i] + offset, this.value[i]) === false) return false; } map(offset, changes) { let value = [], from = [], to = [], newPos = -1, maxPoint = -1; for (let i = 0; i < this.value.length; i++) { let val = this.value[i], curFrom = this.from[i] + offset, curTo = this.to[i] + offset, newFrom, newTo; if (curFrom == curTo) { let mapped = changes.mapPos(curFrom, val.startSide, val.mapMode); if (mapped == null) continue; newFrom = newTo = mapped; if (val.startSide != val.endSide) { newTo = changes.mapPos(curFrom, val.endSide); if (newTo < newFrom) continue; } } else { newFrom = changes.mapPos(curFrom, val.startSide); newTo = changes.mapPos(curTo, val.endSide); if (newFrom > newTo || newFrom == newTo && val.startSide > 0 && val.endSide <= 0) continue; } if ((newTo - newFrom || val.endSide - val.startSide) < 0) continue; if (newPos < 0) newPos = newFrom; if (val.point) maxPoint = Math.max(maxPoint, newTo - newFrom); value.push(val); from.push(newFrom - newPos); to.push(newTo - newPos); } return { mapped: value.length ? new Chunk(from, to, value, maxPoint) : null, pos: newPos }; } } /** A range set stores a collection of [ranges](https://codemirror.net/6/docs/ref/#state.Range) in a way that makes them efficient to [map](https://codemirror.net/6/docs/ref/#state.RangeSet.map) and [update](https://codemirror.net/6/docs/ref/#state.RangeSet.update). This is an immutable data structure. */ class RangeSet { constructor( /** @internal */ chunkPos, /** @internal */ chunk, /** @internal */ nextLayer, /** @internal */ maxPoint) { this.chunkPos = chunkPos; this.chunk = chunk; this.nextLayer = nextLayer; this.maxPoint = maxPoint; } /** @internal */ static create(chunkPos, chunk, nextLayer, maxPoint) { return new RangeSet(chunkPos, chunk, nextLayer, maxPoint); } /** @internal */ get length() { let last = this.chunk.length - 1; return last < 0 ? 0 : Math.max(this.chunkEnd(last), this.nextLayer.length); } /** The number of ranges in the set. */ get size() { if (this.isEmpty) return 0; let size = this.nextLayer.size; for (let chunk of this.chunk) size += chunk.value.length; return size; } /** @internal */ chunkEnd(index) { return this.chunkPos[index] + this.chunk[index].length; } /** Update the range set, optionally adding new ranges or filtering out existing ones. (Note: The type parameter is just there as a kludge to work around TypeScript variance issues that prevented `RangeSet` from being a subtype of `RangeSet` when `X` is a subtype of `Y`.) */ update(updateSpec) { let { add = [], sort = false, filterFrom = 0, filterTo = this.length } = updateSpec; let filter = updateSpec.filter; if (add.length == 0 && !filter) return this; if (sort) add = add.slice().sort(cmpRange); if (this.isEmpty) return add.length ? RangeSet.of(add) : this; let cur = new LayerCursor(this, null, -1).goto(0), i = 0, spill = []; let builder = new RangeSetBuilder(); while (cur.value || i < add.length) { if (i < add.length && (cur.from - add[i].from || cur.startSide - add[i].value.startSide) >= 0) { let range = add[i++]; if (!builder.addInner(range.from, range.to, range.value)) spill.push(range); } else if (cur.rangeIndex == 1 && cur.chunkIndex < this.chunk.length && (i == add.length || this.chunkEnd(cur.chunkIndex) < add[i].from) && (!filter || filterFrom > this.chunkEnd(cur.chunkIndex) || filterTo < this.chunkPos[cur.chunkIndex]) && builder.addChunk(this.chunkPos[cur.chunkIndex], this.chunk[cur.chunkIndex])) { cur.nextChunk(); } else { if (!filter || filterFrom > cur.to || filterTo < cur.from || filter(cur.from, cur.to, cur.value)) { if (!builder.addInner(cur.from, cur.to, cur.value)) spill.push(Range$1.create(cur.from, cur.to, cur.value)); } cur.next(); } } return builder.finishInner(this.nextLayer.isEmpty && !spill.length ? RangeSet.empty : this.nextLayer.update({ add: spill, filter, filterFrom, filterTo })); } /** Map this range set through a set of changes, return the new set. */ map(changes) { if (changes.empty || this.isEmpty) return this; let chunks = [], chunkPos = [], maxPoint = -1; for (let i = 0; i < this.chunk.length; i++) { let start = this.chunkPos[i], chunk = this.chunk[i]; let touch = changes.touchesRange(start, start + chunk.length); if (touch === false) { maxPoint = Math.max(maxPoint, chunk.maxPoint); chunks.push(chunk); chunkPos.push(changes.mapPos(start)); } else if (touch === true) { let { mapped, pos } = chunk.map(start, changes); if (mapped) { maxPoint = Math.max(maxPoint, mapped.maxPoint); chunks.push(mapped); chunkPos.push(pos); } } } let next = this.nextLayer.map(changes); return chunks.length == 0 ? next : new RangeSet(chunkPos, chunks, next || RangeSet.empty, maxPoint); } /** Iterate over the ranges that touch the region `from` to `to`, calling `f` for each. There is no guarantee that the ranges will be reported in any specific order. When the callback returns `false`, iteration stops. */ between(from, to, f) { if (this.isEmpty) return; for (let i = 0; i < this.chunk.length; i++) { let start = this.chunkPos[i], chunk = this.chunk[i]; if (to >= start && from <= start + chunk.length && chunk.between(start, from - start, to - start, f) === false) return; } this.nextLayer.between(from, to, f); } /** Iterate over the ranges in this set, in order, including all ranges that end at or after `from`. */ iter(from = 0) { return HeapCursor.from([this]).goto(from); } /** @internal */ get isEmpty() { return this.nextLayer == this; } /** Iterate over the ranges in a collection of sets, in order, starting from `from`. */ static iter(sets, from = 0) { return HeapCursor.from(sets).goto(from); } /** Iterate over two groups of sets, calling methods on `comparator` to notify it of possible differences. */ static compare(oldSets, newSets, /** This indicates how the underlying data changed between these ranges, and is needed to synchronize the iteration. `from` and `to` are coordinates in the _new_ space, after these changes. */ textDiff, comparator, /** Can be used to ignore all non-point ranges, and points below the given size. When -1, all ranges are compared. */ minPointSize = -1) { let a = oldSets.filter(set => set.maxPoint > 0 || !set.isEmpty && set.maxPoint >= minPointSize); let b = newSets.filter(set => set.maxPoint > 0 || !set.isEmpty && set.maxPoint >= minPointSize); let sharedChunks = findSharedChunks(a, b, textDiff); let sideA = new SpanCursor(a, sharedChunks, minPointSize); let sideB = new SpanCursor(b, sharedChunks, minPointSize); textDiff.iterGaps((fromA, fromB, length) => compare(sideA, fromA, sideB, fromB, length, comparator)); if (textDiff.empty && textDiff.length == 0) compare(sideA, 0, sideB, 0, 0, comparator); } /** Compare the contents of two groups of range sets, returning true if they are equivalent in the given range. */ static eq(oldSets, newSets, from = 0, to) { if (to == null) to = 1000000000 /* C.Far */; let a = oldSets.filter(set => !set.isEmpty && newSets.indexOf(set) < 0); let b = newSets.filter(set => !set.isEmpty && oldSets.indexOf(set) < 0); if (a.length != b.length) return false; if (!a.length) return true; let sharedChunks = findSharedChunks(a, b); let sideA = new SpanCursor(a, sharedChunks, 0).goto(from), sideB = new SpanCursor(b, sharedChunks, 0).goto(from); for (;;) { if (sideA.to != sideB.to || !sameValues(sideA.active, sideB.active) || sideA.point && (!sideB.point || !sideA.point.eq(sideB.point))) return false; if (sideA.to > to) return true; sideA.next(); sideB.next(); } } /** Iterate over a group of range sets at the same time, notifying the iterator about the ranges covering every given piece of content. Returns the open count (see [`SpanIterator.span`](https://codemirror.net/6/docs/ref/#state.SpanIterator.span)) at the end of the iteration. */ static spans(sets, from, to, iterator, /** When given and greater than -1, only points of at least this size are taken into account. */ minPointSize = -1) { let cursor = new SpanCursor(sets, null, minPointSize).goto(from), pos = from; let open = cursor.openStart; for (;;) { let curTo = Math.min(cursor.to, to); if (cursor.point) { iterator.point(pos, curTo, cursor.point, cursor.activeForPoint(cursor.to), open, cursor.pointRank); open = cursor.openEnd(curTo) + (cursor.to > curTo ? 1 : 0); } else if (curTo > pos) { iterator.span(pos, curTo, cursor.active, open); open = cursor.openEnd(curTo); } if (cursor.to > to) break; pos = cursor.to; cursor.next(); } return open; } /** Create a range set for the given range or array of ranges. By default, this expects the ranges to be _sorted_ (by start position and, if two start at the same position, `value.startSide`). You can pass `true` as second argument to cause the method to sort them. */ static of(ranges, sort = false) { let build = new RangeSetBuilder(); for (let range of ranges instanceof Range$1 ? [ranges] : sort ? lazySort(ranges) : ranges) build.add(range.from, range.to, range.value); return build.finish(); } } /** The empty set of ranges. */ RangeSet.empty = /*@__PURE__*/new RangeSet([], [], null, -1); function lazySort(ranges) { if (ranges.length > 1) for (let prev = ranges[0], i = 1; i < ranges.length; i++) { let cur = ranges[i]; if (cmpRange(prev, cur) > 0) return ranges.slice().sort(cmpRange); prev = cur; } return ranges; } RangeSet.empty.nextLayer = RangeSet.empty; /** A range set builder is a data structure that helps build up a [range set](https://codemirror.net/6/docs/ref/#state.RangeSet) directly, without first allocating an array of [`Range`](https://codemirror.net/6/docs/ref/#state.Range) objects. */ class RangeSetBuilder { /** Create an empty builder. */ constructor() { this.chunks = []; this.chunkPos = []; this.chunkStart = -1; this.last = null; this.lastFrom = -1000000000 /* C.Far */; this.lastTo = -1000000000 /* C.Far */; this.from = []; this.to = []; this.value = []; this.maxPoint = -1; this.setMaxPoint = -1; this.nextLayer = null; } finishChunk(newArrays) { this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint)); this.chunkPos.push(this.chunkStart); this.chunkStart = -1; this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint); this.maxPoint = -1; if (newArrays) { this.from = []; this.to = []; this.value = []; } } /** Add a range. Ranges should be added in sorted (by `from` and `value.startSide`) order. */ add(from, to, value) { if (!this.addInner(from, to, value)) (this.nextLayer || (this.nextLayer = new RangeSetBuilder)).add(from, to, value); } /** @internal */ addInner(from, to, value) { let diff = from - this.lastTo || value.startSide - this.last.endSide; if (diff <= 0 && (from - this.lastFrom || value.startSide - this.last.startSide) < 0) throw new Error("Ranges must be added sorted by `from` position and `startSide`"); if (diff < 0) return false; if (this.from.length == 250 /* C.ChunkSize */) this.finishChunk(true); if (this.chunkStart < 0) this.chunkStart = from; this.from.push(from - this.chunkStart); this.to.push(to - this.chunkStart); this.last = value; this.lastFrom = from; this.lastTo = to; this.value.push(value); if (value.point) this.maxPoint = Math.max(this.maxPoint, to - from); return true; } /** @internal */ addChunk(from, chunk) { if ((from - this.lastTo || chunk.value[0].startSide - this.last.endSide) < 0) return false; if (this.from.length) this.finishChunk(true); this.setMaxPoint = Math.max(this.setMaxPoint, chunk.maxPoint); this.chunks.push(chunk); this.chunkPos.push(from); let last = chunk.value.length - 1; this.last = chunk.value[last]; this.lastFrom = chunk.from[last] + from; this.lastTo = chunk.to[last] + from; return true; } /** Finish the range set. Returns the new set. The builder can't be used anymore after this has been called. */ finish() { return this.finishInner(RangeSet.empty); } /** @internal */ finishInner(next) { if (this.from.length) this.finishChunk(false); if (this.chunks.length == 0) return next; let result = RangeSet.create(this.chunkPos, this.chunks, this.nextLayer ? this.nextLayer.finishInner(next) : next, this.setMaxPoint); this.from = null; // Make sure further `add` calls produce errors return result; } } function findSharedChunks(a, b, textDiff) { let inA = new Map(); for (let set of a) for (let i = 0; i < set.chunk.length; i++) if (set.chunk[i].maxPoint <= 0) inA.set(set.chunk[i], set.chunkPos[i]); let shared = new Set(); for (let set of b) for (let i = 0; i < set.chunk.length; i++) { let known = inA.get(set.chunk[i]); if (known != null && (textDiff ? textDiff.mapPos(known) : known) == set.chunkPos[i] && !(textDiff === null || textDiff === void 0 ? void 0 : textDiff.touchesRange(known, known + set.chunk[i].length))) shared.add(set.chunk[i]); } return shared; } class LayerCursor { constructor(layer, skip, minPoint, rank = 0) { this.layer = layer; this.skip = skip; this.minPoint = minPoint; this.rank = rank; } get startSide() { return this.value ? this.value.startSide : 0; } get endSide() { return this.value ? this.value.endSide : 0; } goto(pos, side = -1000000000 /* C.Far */) { this.chunkIndex = this.rangeIndex = 0; this.gotoInner(pos, side, false); return this; } gotoInner(pos, side, forward) { while (this.chunkIndex < this.layer.chunk.length) { let next = this.layer.chunk[this.chunkIndex]; if (!(this.skip && this.skip.has(next) || this.layer.chunkEnd(this.chunkIndex) < pos || next.maxPoint < this.minPoint)) break; this.chunkIndex++; forward = false; } if (this.chunkIndex < this.layer.chunk.length) { let rangeIndex = this.layer.chunk[this.chunkIndex].findIndex(pos - this.layer.chunkPos[this.chunkIndex], side, true); if (!forward || this.rangeIndex < rangeIndex) this.setRangeIndex(rangeIndex); } this.next(); } forward(pos, side) { if ((this.to - pos || this.endSide - side) < 0) this.gotoInner(pos, side, true); } next() { for (;;) { if (this.chunkIndex == this.layer.chunk.length) { this.from = this.to = 1000000000 /* C.Far */; this.value = null; break; } else { let chunkPos = this.layer.chunkPos[this.chunkIndex], chunk = this.layer.chunk[this.chunkIndex]; let from = chunkPos + chunk.from[this.rangeIndex]; this.from = from; this.to = chunkPos + chunk.to[this.rangeIndex]; this.value = chunk.value[this.rangeIndex]; this.setRangeIndex(this.rangeIndex + 1); if (this.minPoint < 0 || this.value.point && this.to - this.from >= this.minPoint) break; } } } setRangeIndex(index) { if (index == this.layer.chunk[this.chunkIndex].value.length) { this.chunkIndex++; if (this.skip) { while (this.chunkIndex < this.layer.chunk.length && this.skip.has(this.layer.chunk[this.chunkIndex])) this.chunkIndex++; } this.rangeIndex = 0; } else { this.rangeIndex = index; } } nextChunk() { this.chunkIndex++; this.rangeIndex = 0; this.next(); } compare(other) { return this.from - other.from || this.startSide - other.startSide || this.rank - other.rank || this.to - other.to || this.endSide - other.endSide; } } class HeapCursor { constructor(heap) { this.heap = heap; } static from(sets, skip = null, minPoint = -1) { let heap = []; for (let i = 0; i < sets.length; i++) { for (let cur = sets[i]; !cur.isEmpty; cur = cur.nextLayer) { if (cur.maxPoint >= minPoint) heap.push(new LayerCursor(cur, skip, minPoint, i)); } } return heap.length == 1 ? heap[0] : new HeapCursor(heap); } get startSide() { return this.value ? this.value.startSide : 0; } goto(pos, side = -1000000000 /* C.Far */) { for (let cur of this.heap) cur.goto(pos, side); for (let i = this.heap.length >> 1; i >= 0; i--) heapBubble(this.heap, i); this.next(); return this; } forward(pos, side) { for (let cur of this.heap) cur.forward(pos, side); for (let i = this.heap.length >> 1; i >= 0; i--) heapBubble(this.heap, i); if ((this.to - pos || this.value.endSide - side) < 0) this.next(); } next() { if (this.heap.length == 0) { this.from = this.to = 1000000000 /* C.Far */; this.value = null; this.rank = -1; } else { let top = this.heap[0]; this.from = top.from; this.to = top.to; this.value = top.value; this.rank = top.rank; if (top.value) top.next(); heapBubble(this.heap, 0); } } } function heapBubble(heap, index) { for (let cur = heap[index];;) { let childIndex = (index << 1) + 1; if (childIndex >= heap.length) break; let child = heap[childIndex]; if (childIndex + 1 < heap.length && child.compare(heap[childIndex + 1]) >= 0) { child = heap[childIndex + 1]; childIndex++; } if (cur.compare(child) < 0) break; heap[childIndex] = cur; heap[index] = child; index = childIndex; } } class SpanCursor { constructor(sets, skip, minPoint) { this.minPoint = minPoint; this.active = []; this.activeTo = []; this.activeRank = []; this.minActive = -1; // A currently active point range, if any this.point = null; this.pointFrom = 0; this.pointRank = 0; this.to = -1000000000 /* C.Far */; this.endSide = 0; this.openStart = -1; this.cursor = HeapCursor.from(sets, skip, minPoint); } goto(pos, side = -1000000000 /* C.Far */) { this.cursor.goto(pos, side); this.active.length = this.activeTo.length = this.activeRank.length = 0; this.minActive = -1; this.to = pos; this.endSide = side; this.openStart = -1; this.next(); return this; } forward(pos, side) { while (this.minActive > -1 && (this.activeTo[this.minActive] - pos || this.active[this.minActive].endSide - side) < 0) this.removeActive(this.minActive); this.cursor.forward(pos, side); } removeActive(index) { remove(this.active, index); remove(this.activeTo, index); remove(this.activeRank, index); this.minActive = findMinIndex(this.active, this.activeTo); } addActive(trackOpen) { let i = 0, { value, to, rank } = this.cursor; while (i < this.activeRank.length && this.activeRank[i] <= rank) i++; insert(this.active, i, value); insert(this.activeTo, i, to); insert(this.activeRank, i, rank); if (trackOpen) insert(trackOpen, i, this.cursor.from); this.minActive = findMinIndex(this.active, this.activeTo); } // After calling this, if `this.point` != null, the next range is a // point. Otherwise, it's a regular range, covered by `this.active`. next() { let from = this.to, wasPoint = this.point; this.point = null; let trackOpen = this.openStart < 0 ? [] : null, trackExtra = 0; for (;;) { let a = this.minActive; if (a > -1 && (this.activeTo[a] - this.cursor.from || this.active[a].endSide - this.cursor.startSide) < 0) { if (this.activeTo[a] > from) { this.to = this.activeTo[a]; this.endSide = this.active[a].endSide; break; } this.removeActive(a); if (trackOpen) remove(trackOpen, a); } else if (!this.cursor.value) { this.to = this.endSide = 1000000000 /* C.Far */; break; } else if (this.cursor.from > from) { this.to = this.cursor.from; this.endSide = this.cursor.startSide; break; } else { let nextVal = this.cursor.value; if (!nextVal.point) { // Opening a range this.addActive(trackOpen); if (this.cursor.from < from && this.cursor.to > from) trackExtra++; this.cursor.next(); } else if (wasPoint && this.cursor.to == this.to && this.cursor.from < this.cursor.to) { // Ignore any non-empty points that end precisely at the end of the prev point this.cursor.next(); } else { // New point this.point = nextVal; this.pointFrom = this.cursor.from; this.pointRank = this.cursor.rank; this.to = this.cursor.to; this.endSide = nextVal.endSide; if (this.cursor.from < from) trackExtra = 1; this.cursor.next(); this.forward(this.to, this.endSide); break; } } } if (trackOpen) { let openStart = 0; while (openStart < trackOpen.length && trackOpen[openStart] < from) openStart++; this.openStart = openStart + trackExtra; } } activeForPoint(to) { if (!this.active.length) return this.active; let active = []; for (let i = this.active.length - 1; i >= 0; i--) { if (this.activeRank[i] < this.pointRank) break; if (this.activeTo[i] > to || this.activeTo[i] == to && this.active[i].endSide >= this.point.endSide) active.push(this.active[i]); } return active.reverse(); } openEnd(to) { let open = 0; for (let i = this.activeTo.length - 1; i >= 0 && this.activeTo[i] > to; i--) open++; return open; } } function compare(a, startA, b, startB, length, comparator) { a.goto(startA); b.goto(startB); let endB = startB + length; let pos = startB, dPos = startB - startA; for (;;) { let diff = (a.to + dPos) - b.to || a.endSide - b.endSide; let end = diff < 0 ? a.to + dPos : b.to, clipEnd = Math.min(end, endB); if (a.point || b.point) { if (!(a.point && b.point && (a.point == b.point || a.point.eq(b.point)) && sameValues(a.activeForPoint(a.to + dPos), b.activeForPoint(b.to)))) comparator.comparePoint(pos, clipEnd, a.point, b.point); } else { if (clipEnd > pos && !sameValues(a.active, b.active)) comparator.compareRange(pos, clipEnd, a.active, b.active); } if (end > endB) break; pos = end; if (diff <= 0) a.next(); if (diff >= 0) b.next(); } } function sameValues(a, b) { if (a.length != b.length) return false; for (let i = 0; i < a.length; i++) if (a[i] != b[i] && !a[i].eq(b[i])) return false; return true; } function remove(array, index) { for (let i = index, e = array.length - 1; i < e; i++) array[i] = array[i + 1]; array.pop(); } function insert(array, index, value) { for (let i = array.length - 1; i >= index; i--) array[i + 1] = array[i]; array[index] = value; } function findMinIndex(value, array) { let found = -1, foundPos = 1000000000 /* C.Far */; for (let i = 0; i < array.length; i++) if ((array[i] - foundPos || value[i].endSide - value[found].endSide) < 0) { found = i; foundPos = array[i]; } return found; } /** Count the column position at the given offset into the string, taking extending characters and tab size into account. */ function countColumn(string, tabSize, to = string.length) { let n = 0; for (let i = 0; i < to;) { if (string.charCodeAt(i) == 9) { n += tabSize - (n % tabSize); i++; } else { n++; i = findClusterBreak(string, i); } } return n; } /** Find the offset that corresponds to the given column position in a string, taking extending characters and tab size into account. By default, the string length is returned when it is too short to reach the column. Pass `strict` true to make it return -1 in that situation. */ function findColumn(string, col, tabSize, strict) { for (let i = 0, n = 0;;) { if (n >= col) return i; if (i == string.length) break; n += string.charCodeAt(i) == 9 ? tabSize - (n % tabSize) : 1; i = findClusterBreak(string, i); } return strict === true ? -1 : string.length; } const C = "\u037c"; const COUNT = typeof Symbol == "undefined" ? "__" + C : Symbol.for(C); const SET = typeof Symbol == "undefined" ? "__styleSet" + Math.floor(Math.random() * 1e8) : Symbol("styleSet"); const top = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : {}; // :: - Style modules encapsulate a set of CSS rules defined from // JavaScript. Their definitions are only available in a given DOM // root after it has been _mounted_ there with `StyleModule.mount`. // // Style modules should be created once and stored somewhere, as // opposed to re-creating them every time you need them. The amount of // CSS rules generated for a given DOM root is bounded by the amount // of style modules that were used. So to avoid leaking rules, don't // create these dynamically, but treat them as one-time allocations. class StyleModule { // :: (Object