Initial commit: n8n Strike API node
- Add Strike API credentials configuration - Implement Strike node with 9 resources (Account, Balance, Currency Exchange, Deposit, Invoice, Payment, Payment Method, Payout, Rates) - Add comprehensive operation descriptions for all resources - Include CLAUDE.MD documentation - Set up build configuration with TypeScript, ESLint, and Prettier 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
20
node_modules/jsonrepair/lib/cjs/index.js
generated
vendored
Normal file
20
node_modules/jsonrepair/lib/cjs/index.js
generated
vendored
Normal file
@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "JSONRepairError", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _JSONRepairError.JSONRepairError;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, "jsonrepair", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _jsonrepair.jsonrepair;
|
||||
}
|
||||
});
|
||||
var _jsonrepair = require("./regular/jsonrepair.js");
|
||||
var _JSONRepairError = require("./utils/JSONRepairError.js");
|
||||
//# sourceMappingURL=index.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/index.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/index.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.js","names":["_jsonrepair","require","_JSONRepairError"],"sources":["../../src/index.ts"],"sourcesContent":["// Cross-platform, non-streaming JavaScript API\nexport { jsonrepair } from './regular/jsonrepair.js'\nexport { JSONRepairError } from './utils/JSONRepairError.js'\n"],"mappings":";;;;;;;;;;;;;;;;;AACA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,gBAAA,GAAAD,OAAA","ignoreList":[]}
|
||||
3
node_modules/jsonrepair/lib/cjs/package.json
generated
vendored
Normal file
3
node_modules/jsonrepair/lib/cjs/package.json
generated
vendored
Normal file
@ -0,0 +1,3 @@
|
||||
{
|
||||
"type": "commonjs"
|
||||
}
|
||||
746
node_modules/jsonrepair/lib/cjs/regular/jsonrepair.js
generated
vendored
Normal file
746
node_modules/jsonrepair/lib/cjs/regular/jsonrepair.js
generated
vendored
Normal file
@ -0,0 +1,746 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.jsonrepair = jsonrepair;
|
||||
var _JSONRepairError = require("../utils/JSONRepairError.js");
|
||||
var _stringUtils = require("../utils/stringUtils.js");
|
||||
const controlCharacters = {
|
||||
'\b': '\\b',
|
||||
'\f': '\\f',
|
||||
'\n': '\\n',
|
||||
'\r': '\\r',
|
||||
'\t': '\\t'
|
||||
};
|
||||
|
||||
// map with all escape characters
|
||||
const escapeCharacters = {
|
||||
'"': '"',
|
||||
'\\': '\\',
|
||||
'/': '/',
|
||||
b: '\b',
|
||||
f: '\f',
|
||||
n: '\n',
|
||||
r: '\r',
|
||||
t: '\t'
|
||||
// note that \u is handled separately in parseString()
|
||||
};
|
||||
|
||||
/**
|
||||
* Repair a string containing an invalid JSON document.
|
||||
* For example changes JavaScript notation into JSON notation.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* try {
|
||||
* const json = "{name: 'John'}"
|
||||
* const repaired = jsonrepair(json)
|
||||
* console.log(repaired)
|
||||
* // '{"name": "John"}'
|
||||
* } catch (err) {
|
||||
* console.error(err)
|
||||
* }
|
||||
*
|
||||
*/
|
||||
function jsonrepair(text) {
|
||||
let i = 0; // current index in text
|
||||
let output = ''; // generated output
|
||||
|
||||
parseMarkdownCodeBlock(['```', '[```', '{```']);
|
||||
const processed = parseValue();
|
||||
if (!processed) {
|
||||
throwUnexpectedEnd();
|
||||
}
|
||||
parseMarkdownCodeBlock(['```', '```]', '```}']);
|
||||
const processedComma = parseCharacter(',');
|
||||
if (processedComma) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
if ((0, _stringUtils.isStartOfValue)(text[i]) && (0, _stringUtils.endsWithCommaOrNewline)(output)) {
|
||||
// start of a new value after end of the root level object: looks like
|
||||
// newline delimited JSON -> turn into a root level array
|
||||
if (!processedComma) {
|
||||
// repair missing comma
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
|
||||
}
|
||||
parseNewlineDelimitedJSON();
|
||||
} else if (processedComma) {
|
||||
// repair: remove trailing comma
|
||||
output = (0, _stringUtils.stripLastOccurrence)(output, ',');
|
||||
}
|
||||
|
||||
// repair redundant end quotes
|
||||
while (text[i] === '}' || text[i] === ']') {
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
if (i >= text.length) {
|
||||
// reached the end of the document properly
|
||||
return output;
|
||||
}
|
||||
throwUnexpectedCharacter();
|
||||
function parseValue() {
|
||||
parseWhitespaceAndSkipComments();
|
||||
const processed = parseObject() || parseArray() || parseString() || parseNumber() || parseKeywords() || parseUnquotedString(false) || parseRegex();
|
||||
parseWhitespaceAndSkipComments();
|
||||
return processed;
|
||||
}
|
||||
function parseWhitespaceAndSkipComments() {
|
||||
let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
|
||||
const start = i;
|
||||
let changed = parseWhitespace(skipNewline);
|
||||
do {
|
||||
changed = parseComment();
|
||||
if (changed) {
|
||||
changed = parseWhitespace(skipNewline);
|
||||
}
|
||||
} while (changed);
|
||||
return i > start;
|
||||
}
|
||||
function parseWhitespace(skipNewline) {
|
||||
const _isWhiteSpace = skipNewline ? _stringUtils.isWhitespace : _stringUtils.isWhitespaceExceptNewline;
|
||||
let whitespace = '';
|
||||
while (true) {
|
||||
if (_isWhiteSpace(text, i)) {
|
||||
whitespace += text[i];
|
||||
i++;
|
||||
} else if ((0, _stringUtils.isSpecialWhitespace)(text, i)) {
|
||||
// repair special whitespace
|
||||
whitespace += ' ';
|
||||
i++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (whitespace.length > 0) {
|
||||
output += whitespace;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseComment() {
|
||||
// find a block comment '/* ... */'
|
||||
if (text[i] === '/' && text[i + 1] === '*') {
|
||||
// repair block comment by skipping it
|
||||
while (i < text.length && !atEndOfBlockComment(text, i)) {
|
||||
i++;
|
||||
}
|
||||
i += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
// find a line comment '// ...'
|
||||
if (text[i] === '/' && text[i + 1] === '/') {
|
||||
// repair line comment by skipping it
|
||||
while (i < text.length && text[i] !== '\n') {
|
||||
i++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseMarkdownCodeBlock(blocks) {
|
||||
// find and skip over a Markdown fenced code block:
|
||||
// ``` ... ```
|
||||
// or
|
||||
// ```json ... ```
|
||||
if (skipMarkdownCodeBlock(blocks)) {
|
||||
if ((0, _stringUtils.isFunctionNameCharStart)(text[i])) {
|
||||
// strip the optional language specifier like "json"
|
||||
while (i < text.length && (0, _stringUtils.isFunctionNameChar)(text[i])) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
parseWhitespaceAndSkipComments();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipMarkdownCodeBlock(blocks) {
|
||||
parseWhitespace(true);
|
||||
for (const block of blocks) {
|
||||
const end = i + block.length;
|
||||
if (text.slice(i, end) === block) {
|
||||
i = end;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseCharacter(char) {
|
||||
if (text[i] === char) {
|
||||
output += text[i];
|
||||
i++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipCharacter(char) {
|
||||
if (text[i] === char) {
|
||||
i++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipEscapeCharacter() {
|
||||
return skipCharacter('\\');
|
||||
}
|
||||
|
||||
/**
|
||||
* Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
|
||||
* or a similar construct in objects.
|
||||
*/
|
||||
function skipEllipsis() {
|
||||
parseWhitespaceAndSkipComments();
|
||||
if (text[i] === '.' && text[i + 1] === '.' && text[i + 2] === '.') {
|
||||
// repair: remove the ellipsis (three dots) and optionally a comma
|
||||
i += 3;
|
||||
parseWhitespaceAndSkipComments();
|
||||
skipCharacter(',');
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an object like '{"key": "value"}'
|
||||
*/
|
||||
function parseObject() {
|
||||
if (text[i] === '{') {
|
||||
output += '{';
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
|
||||
// repair: skip leading comma like in {, message: "hi"}
|
||||
if (skipCharacter(',')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
let initial = true;
|
||||
while (i < text.length && text[i] !== '}') {
|
||||
let processedComma;
|
||||
if (!initial) {
|
||||
processedComma = parseCharacter(',');
|
||||
if (!processedComma) {
|
||||
// repair missing comma
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
|
||||
}
|
||||
parseWhitespaceAndSkipComments();
|
||||
} else {
|
||||
processedComma = true;
|
||||
initial = false;
|
||||
}
|
||||
skipEllipsis();
|
||||
const processedKey = parseString() || parseUnquotedString(true);
|
||||
if (!processedKey) {
|
||||
if (text[i] === '}' || text[i] === '{' || text[i] === ']' || text[i] === '[' || text[i] === undefined) {
|
||||
// repair trailing comma
|
||||
output = (0, _stringUtils.stripLastOccurrence)(output, ',');
|
||||
} else {
|
||||
throwObjectKeyExpected();
|
||||
}
|
||||
break;
|
||||
}
|
||||
parseWhitespaceAndSkipComments();
|
||||
const processedColon = parseCharacter(':');
|
||||
const truncatedText = i >= text.length;
|
||||
if (!processedColon) {
|
||||
if ((0, _stringUtils.isStartOfValue)(text[i]) || truncatedText) {
|
||||
// repair missing colon
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ':');
|
||||
} else {
|
||||
throwColonExpected();
|
||||
}
|
||||
}
|
||||
const processedValue = parseValue();
|
||||
if (!processedValue) {
|
||||
if (processedColon || truncatedText) {
|
||||
// repair missing object value
|
||||
output += 'null';
|
||||
} else {
|
||||
throwColonExpected();
|
||||
}
|
||||
}
|
||||
}
|
||||
if (text[i] === '}') {
|
||||
output += '}';
|
||||
i++;
|
||||
} else {
|
||||
// repair missing end bracket
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, '}');
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse an array like '["item1", "item2", ...]'
|
||||
*/
|
||||
function parseArray() {
|
||||
if (text[i] === '[') {
|
||||
output += '[';
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
|
||||
// repair: skip leading comma like in [,1,2,3]
|
||||
if (skipCharacter(',')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
let initial = true;
|
||||
while (i < text.length && text[i] !== ']') {
|
||||
if (!initial) {
|
||||
const processedComma = parseCharacter(',');
|
||||
if (!processedComma) {
|
||||
// repair missing comma
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
|
||||
}
|
||||
} else {
|
||||
initial = false;
|
||||
}
|
||||
skipEllipsis();
|
||||
const processedValue = parseValue();
|
||||
if (!processedValue) {
|
||||
// repair trailing comma
|
||||
output = (0, _stringUtils.stripLastOccurrence)(output, ',');
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (text[i] === ']') {
|
||||
output += ']';
|
||||
i++;
|
||||
} else {
|
||||
// repair missing closing array bracket
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ']');
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse and repair Newline Delimited JSON (NDJSON):
|
||||
* multiple JSON objects separated by a newline character
|
||||
*/
|
||||
function parseNewlineDelimitedJSON() {
|
||||
// repair NDJSON
|
||||
let initial = true;
|
||||
let processedValue = true;
|
||||
while (processedValue) {
|
||||
if (!initial) {
|
||||
// parse optional comma, insert when missing
|
||||
const processedComma = parseCharacter(',');
|
||||
if (!processedComma) {
|
||||
// repair: add missing comma
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, ',');
|
||||
}
|
||||
} else {
|
||||
initial = false;
|
||||
}
|
||||
processedValue = parseValue();
|
||||
}
|
||||
if (!processedValue) {
|
||||
// repair: remove trailing comma
|
||||
output = (0, _stringUtils.stripLastOccurrence)(output, ',');
|
||||
}
|
||||
|
||||
// repair: wrap the output inside array brackets
|
||||
output = `[\n${output}\n]`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a string enclosed by double quotes "...". Can contain escaped quotes
|
||||
* Repair strings enclosed in single quotes or special quotes
|
||||
* Repair an escaped string
|
||||
*
|
||||
* The function can run in two stages:
|
||||
* - First, it assumes the string has a valid end quote
|
||||
* - If it turns out that the string does not have a valid end quote followed
|
||||
* by a delimiter (which should be the case), the function runs again in a
|
||||
* more conservative way, stopping the string at the first next delimiter
|
||||
* and fixing the string by inserting a quote there, or stopping at a
|
||||
* stop index detected in the first iteration.
|
||||
*/
|
||||
function parseString() {
|
||||
let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
||||
let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
|
||||
let skipEscapeChars = text[i] === '\\';
|
||||
if (skipEscapeChars) {
|
||||
// repair: remove the first escape character
|
||||
i++;
|
||||
skipEscapeChars = true;
|
||||
}
|
||||
if ((0, _stringUtils.isQuote)(text[i])) {
|
||||
// double quotes are correct JSON,
|
||||
// single quotes come from JavaScript for example, we assume it will have a correct single end quote too
|
||||
// otherwise, we will match any double-quote-like start with a double-quote-like end,
|
||||
// or any single-quote-like start with a single-quote-like end
|
||||
const isEndQuote = (0, _stringUtils.isDoubleQuote)(text[i]) ? _stringUtils.isDoubleQuote : (0, _stringUtils.isSingleQuote)(text[i]) ? _stringUtils.isSingleQuote : (0, _stringUtils.isSingleQuoteLike)(text[i]) ? _stringUtils.isSingleQuoteLike : _stringUtils.isDoubleQuoteLike;
|
||||
const iBefore = i;
|
||||
const oBefore = output.length;
|
||||
let str = '"';
|
||||
i++;
|
||||
while (true) {
|
||||
if (i >= text.length) {
|
||||
// end of text, we are missing an end quote
|
||||
|
||||
const iPrev = prevNonWhitespaceIndex(i - 1);
|
||||
if (!stopAtDelimiter && (0, _stringUtils.isDelimiter)(text.charAt(iPrev))) {
|
||||
// if the text ends with a delimiter, like ["hello],
|
||||
// so the missing end quote should be inserted before this delimiter
|
||||
// retry parsing the string, stopping at the first next delimiter
|
||||
i = iBefore;
|
||||
output = output.substring(0, oBefore);
|
||||
return parseString(true);
|
||||
}
|
||||
|
||||
// repair missing quote
|
||||
str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
|
||||
output += str;
|
||||
return true;
|
||||
}
|
||||
if (i === stopAtIndex) {
|
||||
// use the stop index detected in the first iteration, and repair end quote
|
||||
str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
|
||||
output += str;
|
||||
return true;
|
||||
}
|
||||
if (isEndQuote(text[i])) {
|
||||
// end quote
|
||||
// let us check what is before and after the quote to verify whether this is a legit end quote
|
||||
const iQuote = i;
|
||||
const oQuote = str.length;
|
||||
str += '"';
|
||||
i++;
|
||||
output += str;
|
||||
parseWhitespaceAndSkipComments(false);
|
||||
if (stopAtDelimiter || i >= text.length || (0, _stringUtils.isDelimiter)(text[i]) || (0, _stringUtils.isQuote)(text[i]) || (0, _stringUtils.isDigit)(text[i])) {
|
||||
// The quote is followed by the end of the text, a delimiter,
|
||||
// or a next value. So the quote is indeed the end of the string.
|
||||
parseConcatenatedString();
|
||||
return true;
|
||||
}
|
||||
const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
|
||||
const prevChar = text.charAt(iPrevChar);
|
||||
if (prevChar === ',') {
|
||||
// A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
|
||||
// We assume that the quote is a start quote, and that the end quote
|
||||
// should have been located right before the comma but is missing.
|
||||
i = iBefore;
|
||||
output = output.substring(0, oBefore);
|
||||
return parseString(false, iPrevChar);
|
||||
}
|
||||
if ((0, _stringUtils.isDelimiter)(prevChar)) {
|
||||
// This is not the right end quote: it is preceded by a delimiter,
|
||||
// and NOT followed by a delimiter. So, there is an end quote missing
|
||||
// parse the string again and then stop at the first next delimiter
|
||||
i = iBefore;
|
||||
output = output.substring(0, oBefore);
|
||||
return parseString(true);
|
||||
}
|
||||
|
||||
// revert to right after the quote but before any whitespace, and continue parsing the string
|
||||
output = output.substring(0, oBefore);
|
||||
i = iQuote + 1;
|
||||
|
||||
// repair unescaped quote
|
||||
str = `${str.substring(0, oQuote)}\\${str.substring(oQuote)}`;
|
||||
} else if (stopAtDelimiter && (0, _stringUtils.isUnquotedStringDelimiter)(text[i])) {
|
||||
// we're in the mode to stop the string at the first delimiter
|
||||
// because there is an end quote missing
|
||||
|
||||
// test start of an url like "https://..." (this would be parsed as a comment)
|
||||
if (text[i - 1] === ':' && _stringUtils.regexUrlStart.test(text.substring(iBefore + 1, i + 2))) {
|
||||
while (i < text.length && _stringUtils.regexUrlChar.test(text[i])) {
|
||||
str += text[i];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// repair missing quote
|
||||
str = (0, _stringUtils.insertBeforeLastWhitespace)(str, '"');
|
||||
output += str;
|
||||
parseConcatenatedString();
|
||||
return true;
|
||||
} else if (text[i] === '\\') {
|
||||
// handle escaped content like \n or \u2605
|
||||
const char = text.charAt(i + 1);
|
||||
const escapeChar = escapeCharacters[char];
|
||||
if (escapeChar !== undefined) {
|
||||
str += text.slice(i, i + 2);
|
||||
i += 2;
|
||||
} else if (char === 'u') {
|
||||
let j = 2;
|
||||
while (j < 6 && (0, _stringUtils.isHex)(text[i + j])) {
|
||||
j++;
|
||||
}
|
||||
if (j === 6) {
|
||||
str += text.slice(i, i + 6);
|
||||
i += 6;
|
||||
} else if (i + j >= text.length) {
|
||||
// repair invalid or truncated unicode char at the end of the text
|
||||
// by removing the unicode char and ending the string here
|
||||
i = text.length;
|
||||
} else {
|
||||
throwInvalidUnicodeCharacter();
|
||||
}
|
||||
} else {
|
||||
// repair invalid escape character: remove it
|
||||
str += char;
|
||||
i += 2;
|
||||
}
|
||||
} else {
|
||||
// handle regular characters
|
||||
const char = text.charAt(i);
|
||||
if (char === '"' && text[i - 1] !== '\\') {
|
||||
// repair unescaped double quote
|
||||
str += `\\${char}`;
|
||||
i++;
|
||||
} else if ((0, _stringUtils.isControlCharacter)(char)) {
|
||||
// unescaped control character
|
||||
str += controlCharacters[char];
|
||||
i++;
|
||||
} else {
|
||||
if (!(0, _stringUtils.isValidStringCharacter)(char)) {
|
||||
throwInvalidCharacter(char);
|
||||
}
|
||||
str += char;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (skipEscapeChars) {
|
||||
// repair: skipped escape character (nothing to do)
|
||||
skipEscapeCharacter();
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Repair concatenated strings like "hello" + "world", change this into "helloworld"
|
||||
*/
|
||||
function parseConcatenatedString() {
|
||||
let processed = false;
|
||||
parseWhitespaceAndSkipComments();
|
||||
while (text[i] === '+') {
|
||||
processed = true;
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
|
||||
// repair: remove the end quote of the first string
|
||||
output = (0, _stringUtils.stripLastOccurrence)(output, '"', true);
|
||||
const start = output.length;
|
||||
const parsedStr = parseString();
|
||||
if (parsedStr) {
|
||||
// repair: remove the start quote of the second string
|
||||
output = (0, _stringUtils.removeAtIndex)(output, start, 1);
|
||||
} else {
|
||||
// repair: remove the + because it is not followed by a string
|
||||
output = (0, _stringUtils.insertBeforeLastWhitespace)(output, '"');
|
||||
}
|
||||
}
|
||||
return processed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a number like 2.4 or 2.4e6
|
||||
*/
|
||||
function parseNumber() {
|
||||
const start = i;
|
||||
if (text[i] === '-') {
|
||||
i++;
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return true;
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(text[i])) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Note that in JSON leading zeros like "00789" are not allowed.
|
||||
// We will allow all leading zeros here though and at the end of parseNumber
|
||||
// check against trailing zeros and repair that if needed.
|
||||
// Leading zeros can have meaning, so we should not clear them.
|
||||
while ((0, _stringUtils.isDigit)(text[i])) {
|
||||
i++;
|
||||
}
|
||||
if (text[i] === '.') {
|
||||
i++;
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return true;
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(text[i])) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
while ((0, _stringUtils.isDigit)(text[i])) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (text[i] === 'e' || text[i] === 'E') {
|
||||
i++;
|
||||
if (text[i] === '-' || text[i] === '+') {
|
||||
i++;
|
||||
}
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return true;
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(text[i])) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
while ((0, _stringUtils.isDigit)(text[i])) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// if we're not at the end of the number by this point, allow this to be parsed as another type
|
||||
if (!atEndOfNumber()) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
if (i > start) {
|
||||
// repair a number with leading zeros like "00789"
|
||||
const num = text.slice(start, i);
|
||||
const hasInvalidLeadingZero = /^0\d/.test(num);
|
||||
output += hasInvalidLeadingZero ? `"${num}"` : num;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse keywords true, false, null
|
||||
* Repair Python keywords True, False, None
|
||||
*/
|
||||
function parseKeywords() {
|
||||
return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
|
||||
// repair Python keywords True, False, None
|
||||
parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
|
||||
}
|
||||
function parseKeyword(name, value) {
|
||||
if (text.slice(i, i + name.length) === name) {
|
||||
output += value;
|
||||
i += name.length;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Repair an unquoted string by adding quotes around it
|
||||
* Repair a MongoDB function call like NumberLong("2")
|
||||
* Repair a JSONP function call like callback({...});
|
||||
*/
|
||||
function parseUnquotedString(isKey) {
|
||||
// note that the symbol can end with whitespaces: we stop at the next delimiter
|
||||
// also, note that we allow strings to contain a slash / in order to support repairing regular expressions
|
||||
const start = i;
|
||||
if ((0, _stringUtils.isFunctionNameCharStart)(text[i])) {
|
||||
while (i < text.length && (0, _stringUtils.isFunctionNameChar)(text[i])) {
|
||||
i++;
|
||||
}
|
||||
let j = i;
|
||||
while ((0, _stringUtils.isWhitespace)(text, j)) {
|
||||
j++;
|
||||
}
|
||||
if (text[j] === '(') {
|
||||
// repair a MongoDB function call like NumberLong("2")
|
||||
// repair a JSONP function call like callback({...});
|
||||
i = j + 1;
|
||||
parseValue();
|
||||
if (text[i] === ')') {
|
||||
// repair: skip close bracket of function call
|
||||
i++;
|
||||
if (text[i] === ';') {
|
||||
// repair: skip semicolon after JSONP call
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
while (i < text.length && !(0, _stringUtils.isUnquotedStringDelimiter)(text[i]) && !(0, _stringUtils.isQuote)(text[i]) && (!isKey || text[i] !== ':')) {
|
||||
i++;
|
||||
}
|
||||
|
||||
// test start of an url like "https://..." (this would be parsed as a comment)
|
||||
if (text[i - 1] === ':' && _stringUtils.regexUrlStart.test(text.substring(start, i + 2))) {
|
||||
while (i < text.length && _stringUtils.regexUrlChar.test(text[i])) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (i > start) {
|
||||
// repair unquoted string
|
||||
// also, repair undefined into null
|
||||
|
||||
// first, go back to prevent getting trailing whitespaces in the string
|
||||
while ((0, _stringUtils.isWhitespace)(text, i - 1) && i > 0) {
|
||||
i--;
|
||||
}
|
||||
const symbol = text.slice(start, i);
|
||||
output += symbol === 'undefined' ? 'null' : JSON.stringify(symbol);
|
||||
if (text[i] === '"') {
|
||||
// we had a missing start quote, but now we encountered the end quote, so we can skip that one
|
||||
i++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
function parseRegex() {
|
||||
if (text[i] === '/') {
|
||||
const start = i;
|
||||
i++;
|
||||
while (i < text.length && (text[i] !== '/' || text[i - 1] === '\\')) {
|
||||
i++;
|
||||
}
|
||||
i++;
|
||||
output += `"${text.substring(start, i)}"`;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
function prevNonWhitespaceIndex(start) {
|
||||
let prev = start;
|
||||
while (prev > 0 && (0, _stringUtils.isWhitespace)(text, prev)) {
|
||||
prev--;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
function atEndOfNumber() {
|
||||
return i >= text.length || (0, _stringUtils.isDelimiter)(text[i]) || (0, _stringUtils.isWhitespace)(text, i);
|
||||
}
|
||||
function repairNumberEndingWithNumericSymbol(start) {
|
||||
// repair numbers cut off at the end
|
||||
// this will only be called when we end after a '.', '-', or 'e' and does not
|
||||
// change the number more than it needs to make it valid JSON
|
||||
output += `${text.slice(start, i)}0`;
|
||||
}
|
||||
function throwInvalidCharacter(char) {
|
||||
throw new _JSONRepairError.JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
|
||||
}
|
||||
function throwUnexpectedCharacter() {
|
||||
throw new _JSONRepairError.JSONRepairError(`Unexpected character ${JSON.stringify(text[i])}`, i);
|
||||
}
|
||||
function throwUnexpectedEnd() {
|
||||
throw new _JSONRepairError.JSONRepairError('Unexpected end of json string', text.length);
|
||||
}
|
||||
function throwObjectKeyExpected() {
|
||||
throw new _JSONRepairError.JSONRepairError('Object key expected', i);
|
||||
}
|
||||
function throwColonExpected() {
|
||||
throw new _JSONRepairError.JSONRepairError('Colon expected', i);
|
||||
}
|
||||
function throwInvalidUnicodeCharacter() {
|
||||
const chars = text.slice(i, i + 6);
|
||||
throw new _JSONRepairError.JSONRepairError(`Invalid unicode character "${chars}"`, i);
|
||||
}
|
||||
}
|
||||
function atEndOfBlockComment(text, i) {
|
||||
return text[i] === '*' && text[i + 1] === '/';
|
||||
}
|
||||
//# sourceMappingURL=jsonrepair.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/regular/jsonrepair.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/regular/jsonrepair.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
13
node_modules/jsonrepair/lib/cjs/stream.js
generated
vendored
Normal file
13
node_modules/jsonrepair/lib/cjs/stream.js
generated
vendored
Normal file
@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "jsonrepairTransform", {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _stream.jsonrepairTransform;
|
||||
}
|
||||
});
|
||||
var _stream = require("./streaming/stream.js");
|
||||
//# sourceMappingURL=stream.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/stream.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/stream.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"stream.js","names":["_stream","require"],"sources":["../../src/stream.ts"],"sourcesContent":["// Node.js streaming API\nexport { type JsonRepairTransformOptions, jsonrepairTransform } from './streaming/stream.js'\n"],"mappings":";;;;;;;;;;;AACA,IAAAA,OAAA,GAAAC,OAAA","ignoreList":[]}
|
||||
75
node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js
generated
vendored
Normal file
75
node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js
generated
vendored
Normal file
@ -0,0 +1,75 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.createInputBuffer = createInputBuffer;
|
||||
function createInputBuffer() {
|
||||
let buffer = '';
|
||||
let offset = 0;
|
||||
let currentLength = 0;
|
||||
let closed = false;
|
||||
function ensure(index) {
|
||||
if (index < offset) {
|
||||
throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`);
|
||||
}
|
||||
if (index >= currentLength) {
|
||||
if (!closed) {
|
||||
throw new Error(`${indexOutOfRangeMessage} (index: ${index})`);
|
||||
}
|
||||
}
|
||||
}
|
||||
function push(chunk) {
|
||||
buffer += chunk;
|
||||
currentLength += chunk.length;
|
||||
}
|
||||
function flush(position) {
|
||||
if (position > currentLength) {
|
||||
return;
|
||||
}
|
||||
buffer = buffer.substring(position - offset);
|
||||
offset = position;
|
||||
}
|
||||
function charAt(index) {
|
||||
ensure(index);
|
||||
return buffer.charAt(index - offset);
|
||||
}
|
||||
function charCodeAt(index) {
|
||||
ensure(index);
|
||||
return buffer.charCodeAt(index - offset);
|
||||
}
|
||||
function substring(start, end) {
|
||||
ensure(end - 1); // -1 because end is excluded
|
||||
ensure(start);
|
||||
return buffer.slice(start - offset, end - offset);
|
||||
}
|
||||
function length() {
|
||||
if (!closed) {
|
||||
throw new Error('Cannot get length: input is not yet closed');
|
||||
}
|
||||
return currentLength;
|
||||
}
|
||||
function isEnd(index) {
|
||||
if (!closed) {
|
||||
ensure(index);
|
||||
}
|
||||
return index >= currentLength;
|
||||
}
|
||||
function close() {
|
||||
closed = true;
|
||||
}
|
||||
return {
|
||||
push,
|
||||
flush,
|
||||
charAt,
|
||||
charCodeAt,
|
||||
substring,
|
||||
length,
|
||||
currentLength: () => currentLength,
|
||||
currentBufferSize: () => buffer.length,
|
||||
isEnd,
|
||||
close
|
||||
};
|
||||
}
|
||||
const indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size';
|
||||
//# sourceMappingURL=InputBuffer.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/streaming/buffer/InputBuffer.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"InputBuffer.js","names":["createInputBuffer","buffer","offset","currentLength","closed","ensure","index","Error","indexOutOfRangeMessage","push","chunk","length","flush","position","substring","charAt","charCodeAt","start","end","slice","isEnd","close","currentBufferSize"],"sources":["../../../../src/streaming/buffer/InputBuffer.ts"],"sourcesContent":["export interface InputBuffer {\n push: (chunk: string) => void\n flush: (position: number) => void\n charAt: (index: number) => string\n charCodeAt: (index: number) => number\n substring: (start: number, end: number) => string\n length: () => number\n currentLength: () => number\n currentBufferSize: () => number\n isEnd: (index: number) => boolean\n close: () => void\n}\n\nexport function createInputBuffer(): InputBuffer {\n let buffer = ''\n let offset = 0\n let currentLength = 0\n let closed = false\n\n function ensure(index: number) {\n if (index < offset) {\n throw new Error(`${indexOutOfRangeMessage} (index: ${index}, offset: ${offset})`)\n }\n\n if (index >= currentLength) {\n if (!closed) {\n throw new Error(`${indexOutOfRangeMessage} (index: ${index})`)\n }\n }\n }\n\n function push(chunk: string) {\n buffer += chunk\n currentLength += chunk.length\n }\n\n function flush(position: number) {\n if (position > currentLength) {\n return\n }\n\n buffer = buffer.substring(position - offset)\n offset = position\n }\n\n function charAt(index: number): string {\n ensure(index)\n\n return buffer.charAt(index - offset)\n }\n\n function charCodeAt(index: number): number {\n ensure(index)\n\n return buffer.charCodeAt(index - offset)\n }\n\n function substring(start: number, end: number): string {\n ensure(end - 1) // -1 because end is excluded\n ensure(start)\n\n return buffer.slice(start - offset, end - offset)\n }\n\n function length(): number {\n if (!closed) {\n throw new Error('Cannot get length: input is not yet closed')\n }\n\n return currentLength\n }\n\n function isEnd(index: number): boolean {\n if (!closed) {\n ensure(index)\n }\n\n return index >= currentLength\n }\n\n function close() {\n closed = true\n }\n\n return {\n push,\n flush,\n charAt,\n charCodeAt,\n substring,\n length,\n currentLength: () => currentLength,\n currentBufferSize: () => buffer.length,\n isEnd,\n close\n }\n}\n\nconst indexOutOfRangeMessage = 'Index out of range, please configure a larger buffer size'\n"],"mappings":";;;;;;AAaO,SAASA,iBAAiBA,CAAA,EAAgB;EAC/C,IAAIC,MAAM,GAAG,EAAE;EACf,IAAIC,MAAM,GAAG,CAAC;EACd,IAAIC,aAAa,GAAG,CAAC;EACrB,IAAIC,MAAM,GAAG,KAAK;EAElB,SAASC,MAAMA,CAACC,KAAa,EAAE;IAC7B,IAAIA,KAAK,GAAGJ,MAAM,EAAE;MAClB,MAAM,IAAIK,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,aAAaJ,MAAM,GAAG,CAAC;IACnF;IAEA,IAAII,KAAK,IAAIH,aAAa,EAAE;MAC1B,IAAI,CAACC,MAAM,EAAE;QACX,MAAM,IAAIG,KAAK,CAAC,GAAGC,sBAAsB,YAAYF,KAAK,GAAG,CAAC;MAChE;IACF;EACF;EAEA,SAASG,IAAIA,CAACC,KAAa,EAAE;IAC3BT,MAAM,IAAIS,KAAK;IACfP,aAAa,IAAIO,KAAK,CAACC,MAAM;EAC/B;EAEA,SAASC,KAAKA,CAACC,QAAgB,EAAE;IAC/B,IAAIA,QAAQ,GAAGV,aAAa,EAAE;MAC5B;IACF;IAEAF,MAAM,GAAGA,MAAM,CAACa,SAAS,CAACD,QAAQ,GAAGX,MAAM,CAAC;IAC5CA,MAAM,GAAGW,QAAQ;EACnB;EAEA,SAASE,MAAMA,CAACT,KAAa,EAAU;IACrCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACc,MAAM,CAACT,KAAK,GAAGJ,MAAM,CAAC;EACtC;EAEA,SAASc,UAAUA,CAACV,KAAa,EAAU;IACzCD,MAAM,CAACC,KAAK,CAAC;IAEb,OAAOL,MAAM,CAACe,UAAU,CAACV,KAAK,GAAGJ,MAAM,CAAC;EAC1C;EAEA,SAASY,SAASA,CAACG,KAAa,EAAEC,GAAW,EAAU;IACrDb,MAAM,CAACa,GAAG,GAAG,CAAC,CAAC,EAAC;IAChBb,MAAM,CAACY,KAAK,CAAC;IAEb,OAAOhB,MAAM,CAACkB,KAAK,CAACF,KAAK,GAAGf,MAAM,EAAEgB,GAAG,GAAGhB,MAAM,CAAC;EACnD;EAEA,SAASS,MAAMA,CAAA,EAAW;IACxB,IAAI,CAACP,MAAM,EAAE;MACX,MAAM,IAAIG,KAAK,CAAC,4CAA4C,CAAC;IAC/D;IAEA,OAAOJ,aAAa;EACtB;EAEA,SAASiB,KAAKA,CAACd,KAAa,EAAW;IACrC,IAAI,CAACF,MAAM,EAAE;MACXC,MAAM,CAACC,KAAK,CAAC;IACf;IAEA,OAAOA,KAAK,IAAIH,aAAa;EAC/B;EAEA,SAASkB,KAAKA,CAAA,EAAG;IACfjB,MAAM,GAAG,IAAI;EACf;EAEA,OAAO;IACLK,IAAI;IACJG,KAAK;IACLG,MAAM;IACNC,UAAU;IACVF,SAAS;IACTH,MAAM;IACNR,aAAa,EAAEA,CAAA,KAAMA,aAAa;IAClCmB,iBAAiB,EAAEA,CAAA,KAAMrB,MAAM,CAACU,MAAM;IACtCS,KAAK;IACLC;EACF,CAAC;AACH;AAEA,MAAMb,sBAAsB,GAAG,2DAA2D","ignoreList":[]}
|
||||
117
node_modules/jsonrepair/lib/cjs/streaming/buffer/OutputBuffer.js
generated
vendored
Normal file
117
node_modules/jsonrepair/lib/cjs/streaming/buffer/OutputBuffer.js
generated
vendored
Normal file
@ -0,0 +1,117 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.createOutputBuffer = createOutputBuffer;
|
||||
var _stringUtils = require("../../utils/stringUtils.js");
|
||||
function createOutputBuffer(_ref) {
|
||||
let {
|
||||
write,
|
||||
chunkSize,
|
||||
bufferSize
|
||||
} = _ref;
|
||||
let buffer = '';
|
||||
let offset = 0;
|
||||
function flushChunks() {
|
||||
let minSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : bufferSize;
|
||||
while (buffer.length >= minSize + chunkSize) {
|
||||
const chunk = buffer.substring(0, chunkSize);
|
||||
write(chunk);
|
||||
offset += chunkSize;
|
||||
buffer = buffer.substring(chunkSize);
|
||||
}
|
||||
}
|
||||
function flush() {
|
||||
flushChunks(0);
|
||||
if (buffer.length > 0) {
|
||||
write(buffer);
|
||||
offset += buffer.length;
|
||||
buffer = '';
|
||||
}
|
||||
}
|
||||
function push(text) {
|
||||
buffer += text;
|
||||
flushChunks();
|
||||
}
|
||||
function unshift(text) {
|
||||
if (offset > 0) {
|
||||
throw new Error(`Cannot unshift: ${flushedMessage}`);
|
||||
}
|
||||
buffer = text + buffer;
|
||||
flushChunks();
|
||||
}
|
||||
function remove(start, end) {
|
||||
if (start < offset) {
|
||||
throw new Error(`Cannot remove: ${flushedMessage}`);
|
||||
}
|
||||
if (end !== undefined) {
|
||||
buffer = buffer.substring(0, start - offset) + buffer.substring(end - offset);
|
||||
} else {
|
||||
buffer = buffer.substring(0, start - offset);
|
||||
}
|
||||
}
|
||||
function insertAt(index, text) {
|
||||
if (index < offset) {
|
||||
throw new Error(`Cannot insert: ${flushedMessage}`);
|
||||
}
|
||||
buffer = buffer.substring(0, index - offset) + text + buffer.substring(index - offset);
|
||||
}
|
||||
function length() {
|
||||
return offset + buffer.length;
|
||||
}
|
||||
function stripLastOccurrence(textToStrip) {
|
||||
let stripRemainingText = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
||||
const bufferIndex = buffer.lastIndexOf(textToStrip);
|
||||
if (bufferIndex !== -1) {
|
||||
if (stripRemainingText) {
|
||||
buffer = buffer.substring(0, bufferIndex);
|
||||
} else {
|
||||
buffer = buffer.substring(0, bufferIndex) + buffer.substring(bufferIndex + textToStrip.length);
|
||||
}
|
||||
}
|
||||
}
|
||||
function insertBeforeLastWhitespace(textToInsert) {
|
||||
let bufferIndex = buffer.length; // index relative to the start of the buffer, not taking `offset` into account
|
||||
|
||||
if (!(0, _stringUtils.isWhitespace)(buffer, bufferIndex - 1)) {
|
||||
// no trailing whitespaces
|
||||
push(textToInsert);
|
||||
return;
|
||||
}
|
||||
while ((0, _stringUtils.isWhitespace)(buffer, bufferIndex - 1)) {
|
||||
bufferIndex--;
|
||||
}
|
||||
if (bufferIndex <= 0) {
|
||||
throw new Error(`Cannot insert: ${flushedMessage}`);
|
||||
}
|
||||
buffer = buffer.substring(0, bufferIndex) + textToInsert + buffer.substring(bufferIndex);
|
||||
flushChunks();
|
||||
}
|
||||
function endsWithIgnoringWhitespace(char) {
|
||||
let i = buffer.length - 1;
|
||||
while (i > 0) {
|
||||
if (char === buffer.charAt(i)) {
|
||||
return true;
|
||||
}
|
||||
if (!(0, _stringUtils.isWhitespace)(buffer, i)) {
|
||||
return false;
|
||||
}
|
||||
i--;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return {
|
||||
push,
|
||||
unshift,
|
||||
remove,
|
||||
insertAt,
|
||||
length,
|
||||
flush,
|
||||
stripLastOccurrence,
|
||||
insertBeforeLastWhitespace,
|
||||
endsWithIgnoringWhitespace
|
||||
};
|
||||
}
|
||||
const flushedMessage = 'start of the output is already flushed from the buffer';
|
||||
//# sourceMappingURL=OutputBuffer.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/streaming/buffer/OutputBuffer.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/streaming/buffer/OutputBuffer.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
824
node_modules/jsonrepair/lib/cjs/streaming/core.js
generated
vendored
Normal file
824
node_modules/jsonrepair/lib/cjs/streaming/core.js
generated
vendored
Normal file
@ -0,0 +1,824 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.jsonrepairCore = jsonrepairCore;
|
||||
var _JSONRepairError = require("../utils/JSONRepairError.js");
|
||||
var _stringUtils = require("../utils/stringUtils.js");
|
||||
var _InputBuffer = require("./buffer/InputBuffer.js");
|
||||
var _OutputBuffer = require("./buffer/OutputBuffer.js");
|
||||
var _stack = require("./stack.js");
|
||||
const controlCharacters = {
|
||||
'\b': '\\b',
|
||||
'\f': '\\f',
|
||||
'\n': '\\n',
|
||||
'\r': '\\r',
|
||||
'\t': '\\t'
|
||||
};
|
||||
|
||||
// map with all escape characters
|
||||
const escapeCharacters = {
|
||||
'"': '"',
|
||||
'\\': '\\',
|
||||
'/': '/',
|
||||
b: '\b',
|
||||
f: '\f',
|
||||
n: '\n',
|
||||
r: '\r',
|
||||
t: '\t'
|
||||
// note that \u is handled separately in parseString()
|
||||
};
|
||||
function jsonrepairCore(_ref) {
|
||||
let {
|
||||
onData,
|
||||
bufferSize = 65536,
|
||||
chunkSize = 65536
|
||||
} = _ref;
|
||||
const input = (0, _InputBuffer.createInputBuffer)();
|
||||
const output = (0, _OutputBuffer.createOutputBuffer)({
|
||||
write: onData,
|
||||
bufferSize,
|
||||
chunkSize
|
||||
});
|
||||
let i = 0;
|
||||
let iFlushed = 0;
|
||||
const stack = (0, _stack.createStack)();
|
||||
function flushInputBuffer() {
|
||||
while (iFlushed < i - bufferSize - chunkSize) {
|
||||
iFlushed += chunkSize;
|
||||
input.flush(iFlushed);
|
||||
}
|
||||
}
|
||||
function transform(chunk) {
|
||||
input.push(chunk);
|
||||
while (i < input.currentLength() - bufferSize && parse()) {
|
||||
// loop until there is nothing more to process
|
||||
}
|
||||
flushInputBuffer();
|
||||
}
|
||||
function flush() {
|
||||
input.close();
|
||||
while (parse()) {
|
||||
// loop until there is nothing more to process
|
||||
}
|
||||
output.flush();
|
||||
}
|
||||
function parse() {
|
||||
parseWhitespaceAndSkipComments();
|
||||
switch (stack.type) {
|
||||
case _stack.StackType.object:
|
||||
{
|
||||
switch (stack.caret) {
|
||||
case _stack.Caret.beforeKey:
|
||||
return skipEllipsis() || parseObjectKey() || parseUnexpectedColon() || parseRepairTrailingComma() || parseRepairObjectEndOrComma();
|
||||
case _stack.Caret.beforeValue:
|
||||
return parseValue() || parseRepairMissingObjectValue();
|
||||
case _stack.Caret.afterValue:
|
||||
return parseObjectComma() || parseObjectEnd() || parseRepairObjectEndOrComma();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case _stack.StackType.array:
|
||||
{
|
||||
switch (stack.caret) {
|
||||
case _stack.Caret.beforeValue:
|
||||
return skipEllipsis() || parseValue() || parseRepairTrailingComma() || parseRepairArrayEnd();
|
||||
case _stack.Caret.afterValue:
|
||||
return parseArrayComma() || parseArrayEnd() || parseRepairMissingComma() || parseRepairArrayEnd();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case _stack.StackType.ndJson:
|
||||
{
|
||||
switch (stack.caret) {
|
||||
case _stack.Caret.beforeValue:
|
||||
return parseValue() || parseRepairTrailingComma();
|
||||
case _stack.Caret.afterValue:
|
||||
return parseArrayComma() || parseRepairMissingComma() || parseRepairNdJsonEnd();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case _stack.StackType.functionCall:
|
||||
{
|
||||
switch (stack.caret) {
|
||||
case _stack.Caret.beforeValue:
|
||||
return parseValue();
|
||||
case _stack.Caret.afterValue:
|
||||
return parseFunctionCallEnd();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
case _stack.StackType.root:
|
||||
{
|
||||
switch (stack.caret) {
|
||||
case _stack.Caret.beforeValue:
|
||||
return parseRootStart();
|
||||
case _stack.Caret.afterValue:
|
||||
return parseRootEnd();
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
function parseValue() {
|
||||
return parseObjectStart() || parseArrayStart() || parseString() || parseNumber() || parseKeywords() || parseRepairUnquotedString() || parseRepairRegex();
|
||||
}
|
||||
function parseObjectStart() {
|
||||
if (parseCharacter('{')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
skipEllipsis();
|
||||
if (skipCharacter(',')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
if (parseCharacter('}')) {
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return stack.push(_stack.StackType.object, _stack.Caret.beforeKey);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseArrayStart() {
|
||||
if (parseCharacter('[')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
skipEllipsis();
|
||||
if (skipCharacter(',')) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
if (parseCharacter(']')) {
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return stack.push(_stack.StackType.array, _stack.Caret.beforeValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseRepairUnquotedString() {
|
||||
let j = i;
|
||||
if ((0, _stringUtils.isFunctionNameCharStart)(input.charAt(j))) {
|
||||
while (!input.isEnd(j) && (0, _stringUtils.isFunctionNameChar)(input.charAt(j))) {
|
||||
j++;
|
||||
}
|
||||
let k = j;
|
||||
while ((0, _stringUtils.isWhitespace)(input, k)) {
|
||||
k++;
|
||||
}
|
||||
if (input.charAt(k) === '(') {
|
||||
// repair a MongoDB function call like NumberLong("2")
|
||||
// repair a JSONP function call like callback({...});
|
||||
k++;
|
||||
i = k;
|
||||
return stack.push(_stack.StackType.functionCall, _stack.Caret.beforeValue);
|
||||
}
|
||||
}
|
||||
j = findNextDelimiter(false, j);
|
||||
if (j !== null) {
|
||||
// test start of an url like "https://..." (this would be parsed as a comment)
|
||||
if (input.charAt(j - 1) === ':' && _stringUtils.regexUrlStart.test(input.substring(i, j + 2))) {
|
||||
while (!input.isEnd(j) && _stringUtils.regexUrlChar.test(input.charAt(j))) {
|
||||
j++;
|
||||
}
|
||||
}
|
||||
const symbol = input.substring(i, j);
|
||||
i = j;
|
||||
output.push(symbol === 'undefined' ? 'null' : JSON.stringify(symbol));
|
||||
if (input.charAt(i) === '"') {
|
||||
// we had a missing start quote, but now we encountered the end quote, so we can skip that one
|
||||
i++;
|
||||
}
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseRepairRegex() {
|
||||
if (input.charAt(i) === '/') {
|
||||
const start = i;
|
||||
i++;
|
||||
while (!input.isEnd(i) && (input.charAt(i) !== '/' || input.charAt(i - 1) === '\\')) {
|
||||
i++;
|
||||
}
|
||||
i++;
|
||||
output.push(`"${input.substring(start, i)}"`);
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
}
|
||||
function parseRepairMissingObjectValue() {
|
||||
// repair missing object value
|
||||
output.push('null');
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
function parseRepairTrailingComma() {
|
||||
// repair trailing comma
|
||||
if (output.endsWithIgnoringWhitespace(',')) {
|
||||
output.stripLastOccurrence(',');
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseUnexpectedColon() {
|
||||
if (input.charAt(i) === ':') {
|
||||
throwObjectKeyExpected();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseUnexpectedEnd() {
|
||||
if (input.isEnd(i)) {
|
||||
throwUnexpectedEnd();
|
||||
} else {
|
||||
throwUnexpectedCharacter();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseObjectKey() {
|
||||
const parsedKey = parseString() || parseUnquotedKey();
|
||||
if (parsedKey) {
|
||||
parseWhitespaceAndSkipComments();
|
||||
if (parseCharacter(':')) {
|
||||
// expect a value after the :
|
||||
return stack.update(_stack.Caret.beforeValue);
|
||||
}
|
||||
const truncatedText = input.isEnd(i);
|
||||
if ((0, _stringUtils.isStartOfValue)(input.charAt(i)) || truncatedText) {
|
||||
// repair missing colon
|
||||
output.insertBeforeLastWhitespace(':');
|
||||
return stack.update(_stack.Caret.beforeValue);
|
||||
}
|
||||
throwColonExpected();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseObjectComma() {
|
||||
if (parseCharacter(',')) {
|
||||
return stack.update(_stack.Caret.beforeKey);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseObjectEnd() {
|
||||
if (parseCharacter('}')) {
|
||||
return stack.pop();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseRepairObjectEndOrComma() {
|
||||
// repair missing object end and trailing comma
|
||||
if (input.charAt(i) === '{') {
|
||||
output.stripLastOccurrence(',');
|
||||
output.insertBeforeLastWhitespace('}');
|
||||
return stack.pop();
|
||||
}
|
||||
|
||||
// repair missing comma
|
||||
if (!input.isEnd(i) && (0, _stringUtils.isStartOfValue)(input.charAt(i))) {
|
||||
output.insertBeforeLastWhitespace(',');
|
||||
return stack.update(_stack.Caret.beforeKey);
|
||||
}
|
||||
|
||||
// repair missing closing brace
|
||||
output.insertBeforeLastWhitespace('}');
|
||||
return stack.pop();
|
||||
}
|
||||
function parseArrayComma() {
|
||||
if (parseCharacter(',')) {
|
||||
return stack.update(_stack.Caret.beforeValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseArrayEnd() {
|
||||
if (parseCharacter(']')) {
|
||||
return stack.pop();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseRepairMissingComma() {
|
||||
// repair missing comma
|
||||
if (!input.isEnd(i) && (0, _stringUtils.isStartOfValue)(input.charAt(i))) {
|
||||
output.insertBeforeLastWhitespace(',');
|
||||
return stack.update(_stack.Caret.beforeValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseRepairArrayEnd() {
|
||||
// repair missing closing bracket
|
||||
output.insertBeforeLastWhitespace(']');
|
||||
return stack.pop();
|
||||
}
|
||||
function parseRepairNdJsonEnd() {
|
||||
if (input.isEnd(i)) {
|
||||
output.push('\n]');
|
||||
return stack.pop();
|
||||
}
|
||||
throwUnexpectedEnd();
|
||||
return false; // just to make TS happy
|
||||
}
|
||||
function parseFunctionCallEnd() {
|
||||
if (skipCharacter(')')) {
|
||||
skipCharacter(';');
|
||||
}
|
||||
return stack.pop();
|
||||
}
|
||||
function parseRootStart() {
|
||||
parseMarkdownCodeBlock(['```', '[```', '{```']);
|
||||
return parseValue() || parseUnexpectedEnd();
|
||||
}
|
||||
function parseRootEnd() {
|
||||
parseMarkdownCodeBlock(['```', '```]', '```}']);
|
||||
const parsedComma = parseCharacter(',');
|
||||
parseWhitespaceAndSkipComments();
|
||||
if ((0, _stringUtils.isStartOfValue)(input.charAt(i)) && (output.endsWithIgnoringWhitespace(',') || output.endsWithIgnoringWhitespace('\n'))) {
|
||||
// start of a new value after end of the root level object: looks like
|
||||
// newline delimited JSON -> turn into a root level array
|
||||
if (!parsedComma) {
|
||||
// repair missing comma
|
||||
output.insertBeforeLastWhitespace(',');
|
||||
}
|
||||
output.unshift('[\n');
|
||||
return stack.push(_stack.StackType.ndJson, _stack.Caret.beforeValue);
|
||||
}
|
||||
if (parsedComma) {
|
||||
// repair: remove trailing comma
|
||||
output.stripLastOccurrence(',');
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
|
||||
// repair redundant end braces and brackets
|
||||
while (input.charAt(i) === '}' || input.charAt(i) === ']') {
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
}
|
||||
if (!input.isEnd(i)) {
|
||||
throwUnexpectedCharacter();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseWhitespaceAndSkipComments() {
|
||||
let skipNewline = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
|
||||
const start = i;
|
||||
let changed = parseWhitespace(skipNewline);
|
||||
do {
|
||||
changed = parseComment();
|
||||
if (changed) {
|
||||
changed = parseWhitespace(skipNewline);
|
||||
}
|
||||
} while (changed);
|
||||
return i > start;
|
||||
}
|
||||
function parseWhitespace(skipNewline) {
|
||||
const _isWhiteSpace = skipNewline ? _stringUtils.isWhitespace : _stringUtils.isWhitespaceExceptNewline;
|
||||
let whitespace = '';
|
||||
while (true) {
|
||||
if (_isWhiteSpace(input, i)) {
|
||||
whitespace += input.charAt(i);
|
||||
i++;
|
||||
} else if ((0, _stringUtils.isSpecialWhitespace)(input, i)) {
|
||||
// repair special whitespace
|
||||
whitespace += ' ';
|
||||
i++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (whitespace.length > 0) {
|
||||
output.push(whitespace);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseComment() {
|
||||
// find a block comment '/* ... */'
|
||||
if (input.charAt(i) === '/' && input.charAt(i + 1) === '*') {
|
||||
// repair block comment by skipping it
|
||||
while (!input.isEnd(i) && !atEndOfBlockComment(i)) {
|
||||
i++;
|
||||
}
|
||||
i += 2;
|
||||
return true;
|
||||
}
|
||||
|
||||
// find a line comment '// ...'
|
||||
if (input.charAt(i) === '/' && input.charAt(i + 1) === '/') {
|
||||
// repair line comment by skipping it
|
||||
while (!input.isEnd(i) && input.charAt(i) !== '\n') {
|
||||
i++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseMarkdownCodeBlock(blocks) {
|
||||
// find and skip over a Markdown fenced code block:
|
||||
// ``` ... ```
|
||||
// or
|
||||
// ```json ... ```
|
||||
if (skipMarkdownCodeBlock(blocks)) {
|
||||
if ((0, _stringUtils.isFunctionNameCharStart)(input.charAt(i))) {
|
||||
// strip the optional language specifier like "json"
|
||||
while (!input.isEnd(i) && (0, _stringUtils.isFunctionNameChar)(input.charAt(i))) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
parseWhitespaceAndSkipComments();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipMarkdownCodeBlock(blocks) {
|
||||
for (const block of blocks) {
|
||||
const end = i + block.length;
|
||||
if (input.substring(i, end) === block) {
|
||||
i = end;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseCharacter(char) {
|
||||
if (input.charAt(i) === char) {
|
||||
output.push(input.charAt(i));
|
||||
i++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipCharacter(char) {
|
||||
if (input.charAt(i) === char) {
|
||||
i++;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function skipEscapeCharacter() {
|
||||
return skipCharacter('\\');
|
||||
}
|
||||
|
||||
/**
|
||||
* Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
|
||||
* or a similar construct in objects.
|
||||
*/
|
||||
function skipEllipsis() {
|
||||
parseWhitespaceAndSkipComments();
|
||||
if (input.charAt(i) === '.' && input.charAt(i + 1) === '.' && input.charAt(i + 2) === '.') {
|
||||
// repair: remove the ellipsis (three dots) and optionally a comma
|
||||
i += 3;
|
||||
parseWhitespaceAndSkipComments();
|
||||
skipCharacter(',');
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a string enclosed by double quotes "...". Can contain escaped quotes
|
||||
* Repair strings enclosed in single quotes or special quotes
|
||||
* Repair an escaped string
|
||||
*
|
||||
* The function can run in two stages:
|
||||
* - First, it assumes the string has a valid end quote
|
||||
* - If it turns out that the string does not have a valid end quote followed
|
||||
* by a delimiter (which should be the case), the function runs again in a
|
||||
* more conservative way, stopping the string at the first next delimiter
|
||||
* and fixing the string by inserting a quote there, or stopping at a
|
||||
* stop index detected in the first iteration.
|
||||
*/
|
||||
function parseString() {
|
||||
let stopAtDelimiter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
||||
let stopAtIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
|
||||
let skipEscapeChars = input.charAt(i) === '\\';
|
||||
if (skipEscapeChars) {
|
||||
// repair: remove the first escape character
|
||||
i++;
|
||||
skipEscapeChars = true;
|
||||
}
|
||||
if ((0, _stringUtils.isQuote)(input.charAt(i))) {
|
||||
// double quotes are correct JSON,
|
||||
// single quotes come from JavaScript for example, we assume it will have a correct single end quote too
|
||||
// otherwise, we will match any double-quote-like start with a double-quote-like end,
|
||||
// or any single-quote-like start with a single-quote-like end
|
||||
const isEndQuote = (0, _stringUtils.isDoubleQuote)(input.charAt(i)) ? _stringUtils.isDoubleQuote : (0, _stringUtils.isSingleQuote)(input.charAt(i)) ? _stringUtils.isSingleQuote : (0, _stringUtils.isSingleQuoteLike)(input.charAt(i)) ? _stringUtils.isSingleQuoteLike : _stringUtils.isDoubleQuoteLike;
|
||||
const iBefore = i;
|
||||
const oBefore = output.length();
|
||||
output.push('"');
|
||||
i++;
|
||||
while (true) {
|
||||
if (input.isEnd(i)) {
|
||||
// end of text, we have a missing quote somewhere
|
||||
|
||||
const iPrev = prevNonWhitespaceIndex(i - 1);
|
||||
if (!stopAtDelimiter && (0, _stringUtils.isDelimiter)(input.charAt(iPrev))) {
|
||||
// if the text ends with a delimiter, like ["hello],
|
||||
// so the missing end quote should be inserted before this delimiter
|
||||
// retry parsing the string, stopping at the first next delimiter
|
||||
i = iBefore;
|
||||
output.remove(oBefore);
|
||||
return parseString(true);
|
||||
}
|
||||
|
||||
// repair missing quote
|
||||
output.insertBeforeLastWhitespace('"');
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
if (i === stopAtIndex) {
|
||||
// use the stop index detected in the first iteration, and repair end quote
|
||||
output.insertBeforeLastWhitespace('"');
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
if (isEndQuote(input.charAt(i))) {
|
||||
// end quote
|
||||
// let us check what is before and after the quote to verify whether this is a legit end quote
|
||||
const iQuote = i;
|
||||
const oQuote = output.length();
|
||||
output.push('"');
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments(false);
|
||||
if (stopAtDelimiter || input.isEnd(i) || (0, _stringUtils.isDelimiter)(input.charAt(i)) || (0, _stringUtils.isQuote)(input.charAt(i)) || (0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
// The quote is followed by the end of the text, a delimiter, or a next value
|
||||
// so the quote is indeed the end of the string
|
||||
parseConcatenatedString();
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
const iPrevChar = prevNonWhitespaceIndex(iQuote - 1);
|
||||
const prevChar = input.charAt(iPrevChar);
|
||||
if (prevChar === ',') {
|
||||
// A comma followed by a quote, like '{"a":"b,c,"d":"e"}'.
|
||||
// We assume that the quote is a start quote, and that the end quote
|
||||
// should have been located right before the comma but is missing.
|
||||
i = iBefore;
|
||||
output.remove(oBefore);
|
||||
return parseString(false, iPrevChar);
|
||||
}
|
||||
if ((0, _stringUtils.isDelimiter)(prevChar)) {
|
||||
// This is not the right end quote: it is preceded by a delimiter,
|
||||
// and NOT followed by a delimiter. So, there is an end quote missing
|
||||
// parse the string again and then stop at the first next delimiter
|
||||
i = iBefore;
|
||||
output.remove(oBefore);
|
||||
return parseString(true);
|
||||
}
|
||||
|
||||
// revert to right after the quote but before any whitespace, and continue parsing the string
|
||||
output.remove(oQuote + 1);
|
||||
i = iQuote + 1;
|
||||
|
||||
// repair unescaped quote
|
||||
output.insertAt(oQuote, '\\');
|
||||
} else if (stopAtDelimiter && (0, _stringUtils.isUnquotedStringDelimiter)(input.charAt(i))) {
|
||||
// we're in the mode to stop the string at the first delimiter
|
||||
// because there is an end quote missing
|
||||
|
||||
// test start of an url like "https://..." (this would be parsed as a comment)
|
||||
if (input.charAt(i - 1) === ':' && _stringUtils.regexUrlStart.test(input.substring(iBefore + 1, i + 2))) {
|
||||
while (!input.isEnd(i) && _stringUtils.regexUrlChar.test(input.charAt(i))) {
|
||||
output.push(input.charAt(i));
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// repair missing quote
|
||||
output.insertBeforeLastWhitespace('"');
|
||||
parseConcatenatedString();
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
} else if (input.charAt(i) === '\\') {
|
||||
// handle escaped content like \n or \u2605
|
||||
const char = input.charAt(i + 1);
|
||||
const escapeChar = escapeCharacters[char];
|
||||
if (escapeChar !== undefined) {
|
||||
output.push(input.substring(i, i + 2));
|
||||
i += 2;
|
||||
} else if (char === 'u') {
|
||||
let j = 2;
|
||||
while (j < 6 && (0, _stringUtils.isHex)(input.charAt(i + j))) {
|
||||
j++;
|
||||
}
|
||||
if (j === 6) {
|
||||
output.push(input.substring(i, i + 6));
|
||||
i += 6;
|
||||
} else if (input.isEnd(i + j)) {
|
||||
// repair invalid or truncated unicode char at the end of the text
|
||||
// by removing the unicode char and ending the string here
|
||||
i += j;
|
||||
} else {
|
||||
throwInvalidUnicodeCharacter();
|
||||
}
|
||||
} else {
|
||||
// repair invalid escape character: remove it
|
||||
output.push(char);
|
||||
i += 2;
|
||||
}
|
||||
} else {
|
||||
// handle regular characters
|
||||
const char = input.charAt(i);
|
||||
if (char === '"' && input.charAt(i - 1) !== '\\') {
|
||||
// repair unescaped double quote
|
||||
output.push(`\\${char}`);
|
||||
i++;
|
||||
} else if ((0, _stringUtils.isControlCharacter)(char)) {
|
||||
// unescaped control character
|
||||
output.push(controlCharacters[char]);
|
||||
i++;
|
||||
} else {
|
||||
if (!(0, _stringUtils.isValidStringCharacter)(char)) {
|
||||
throwInvalidCharacter(char);
|
||||
}
|
||||
output.push(char);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (skipEscapeChars) {
|
||||
// repair: skipped escape character (nothing to do)
|
||||
skipEscapeCharacter();
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Repair concatenated strings like "hello" + "world", change this into "helloworld"
|
||||
*/
|
||||
function parseConcatenatedString() {
|
||||
let parsed = false;
|
||||
parseWhitespaceAndSkipComments();
|
||||
while (input.charAt(i) === '+') {
|
||||
parsed = true;
|
||||
i++;
|
||||
parseWhitespaceAndSkipComments();
|
||||
|
||||
// repair: remove the end quote of the first string
|
||||
output.stripLastOccurrence('"', true);
|
||||
const start = output.length();
|
||||
const parsedStr = parseString();
|
||||
if (parsedStr) {
|
||||
// repair: remove the start quote of the second string
|
||||
output.remove(start, start + 1);
|
||||
} else {
|
||||
// repair: remove the + because it is not followed by a string
|
||||
output.insertBeforeLastWhitespace('"');
|
||||
}
|
||||
}
|
||||
return parsed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a number like 2.4 or 2.4e6
|
||||
*/
|
||||
function parseNumber() {
|
||||
const start = i;
|
||||
if (input.charAt(i) === '-') {
|
||||
i++;
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Note that in JSON leading zeros like "00789" are not allowed.
|
||||
// We will allow all leading zeros here though and at the end of parseNumber
|
||||
// check against trailing zeros and repair that if needed.
|
||||
// Leading zeros can have meaning, so we should not clear them.
|
||||
while ((0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i++;
|
||||
}
|
||||
if (input.charAt(i) === '.') {
|
||||
i++;
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
while ((0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
if (input.charAt(i) === 'e' || input.charAt(i) === 'E') {
|
||||
i++;
|
||||
if (input.charAt(i) === '-' || input.charAt(i) === '+') {
|
||||
i++;
|
||||
}
|
||||
if (atEndOfNumber()) {
|
||||
repairNumberEndingWithNumericSymbol(start);
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
if (!(0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
while ((0, _stringUtils.isDigit)(input.charAt(i))) {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// if we're not at the end of the number by this point, allow this to be parsed as another type
|
||||
if (!atEndOfNumber()) {
|
||||
i = start;
|
||||
return false;
|
||||
}
|
||||
if (i > start) {
|
||||
// repair a number with leading zeros like "00789"
|
||||
const num = input.substring(start, i);
|
||||
const hasInvalidLeadingZero = /^0\d/.test(num);
|
||||
output.push(hasInvalidLeadingZero ? `"${num}"` : num);
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse keywords true, false, null
|
||||
* Repair Python keywords True, False, None
|
||||
*/
|
||||
function parseKeywords() {
|
||||
return parseKeyword('true', 'true') || parseKeyword('false', 'false') || parseKeyword('null', 'null') ||
|
||||
// repair Python keywords True, False, None
|
||||
parseKeyword('True', 'true') || parseKeyword('False', 'false') || parseKeyword('None', 'null');
|
||||
}
|
||||
function parseKeyword(name, value) {
|
||||
if (input.substring(i, i + name.length) === name) {
|
||||
output.push(value);
|
||||
i += name.length;
|
||||
return stack.update(_stack.Caret.afterValue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function parseUnquotedKey() {
|
||||
let end = findNextDelimiter(true, i);
|
||||
if (end !== null) {
|
||||
// first, go back to prevent getting trailing whitespaces in the string
|
||||
while ((0, _stringUtils.isWhitespace)(input, end - 1) && end > i) {
|
||||
end--;
|
||||
}
|
||||
const symbol = input.substring(i, end);
|
||||
output.push(JSON.stringify(symbol));
|
||||
i = end;
|
||||
if (input.charAt(i) === '"') {
|
||||
// we had a missing start quote, but now we encountered the end quote, so we can skip that one
|
||||
i++;
|
||||
}
|
||||
return stack.update(_stack.Caret.afterValue); // we do not have a state Caret.afterKey, therefore we use afterValue here
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function findNextDelimiter(isKey, start) {
|
||||
// note that the symbol can end with whitespaces: we stop at the next delimiter
|
||||
// also, note that we allow strings to contain a slash / in order to support repairing regular expressions
|
||||
let j = start;
|
||||
while (!input.isEnd(j) && !(0, _stringUtils.isUnquotedStringDelimiter)(input.charAt(j)) && !(0, _stringUtils.isQuote)(input.charAt(j)) && (!isKey || input.charAt(j) !== ':')) {
|
||||
j++;
|
||||
}
|
||||
return j > i ? j : null;
|
||||
}
|
||||
function prevNonWhitespaceIndex(start) {
|
||||
let prev = start;
|
||||
while (prev > 0 && (0, _stringUtils.isWhitespace)(input, prev)) {
|
||||
prev--;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
function atEndOfNumber() {
|
||||
return input.isEnd(i) || (0, _stringUtils.isDelimiter)(input.charAt(i)) || (0, _stringUtils.isWhitespace)(input, i);
|
||||
}
|
||||
function repairNumberEndingWithNumericSymbol(start) {
|
||||
// repair numbers cut off at the end
|
||||
// this will only be called when we end after a '.', '-', or 'e' and does not
|
||||
// change the number more than it needs to make it valid JSON
|
||||
output.push(`${input.substring(start, i)}0`);
|
||||
}
|
||||
function throwInvalidCharacter(char) {
|
||||
throw new _JSONRepairError.JSONRepairError(`Invalid character ${JSON.stringify(char)}`, i);
|
||||
}
|
||||
function throwUnexpectedCharacter() {
|
||||
throw new _JSONRepairError.JSONRepairError(`Unexpected character ${JSON.stringify(input.charAt(i))}`, i);
|
||||
}
|
||||
function throwUnexpectedEnd() {
|
||||
throw new _JSONRepairError.JSONRepairError('Unexpected end of json string', i);
|
||||
}
|
||||
function throwObjectKeyExpected() {
|
||||
throw new _JSONRepairError.JSONRepairError('Object key expected', i);
|
||||
}
|
||||
function throwColonExpected() {
|
||||
throw new _JSONRepairError.JSONRepairError('Colon expected', i);
|
||||
}
|
||||
function throwInvalidUnicodeCharacter() {
|
||||
const chars = input.substring(i, i + 6);
|
||||
throw new _JSONRepairError.JSONRepairError(`Invalid unicode character "${chars}"`, i);
|
||||
}
|
||||
function atEndOfBlockComment(i) {
|
||||
return input.charAt(i) === '*' && input.charAt(i + 1) === '/';
|
||||
}
|
||||
return {
|
||||
transform,
|
||||
flush
|
||||
};
|
||||
}
|
||||
//# sourceMappingURL=core.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/streaming/core.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/streaming/core.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
51
node_modules/jsonrepair/lib/cjs/streaming/stack.js
generated
vendored
Normal file
51
node_modules/jsonrepair/lib/cjs/streaming/stack.js
generated
vendored
Normal file
@ -0,0 +1,51 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.StackType = exports.Caret = void 0;
|
||||
exports.createStack = createStack;
|
||||
let Caret = exports.Caret = /*#__PURE__*/function (Caret) {
|
||||
Caret["beforeValue"] = "beforeValue";
|
||||
Caret["afterValue"] = "afterValue";
|
||||
Caret["beforeKey"] = "beforeKey";
|
||||
return Caret;
|
||||
}({});
|
||||
let StackType = exports.StackType = /*#__PURE__*/function (StackType) {
|
||||
StackType["root"] = "root";
|
||||
StackType["object"] = "object";
|
||||
StackType["array"] = "array";
|
||||
StackType["ndJson"] = "ndJson";
|
||||
StackType["functionCall"] = "dataType";
|
||||
return StackType;
|
||||
}({});
|
||||
function createStack() {
|
||||
const stack = [StackType.root];
|
||||
let caret = Caret.beforeValue;
|
||||
return {
|
||||
get type() {
|
||||
return last(stack);
|
||||
},
|
||||
get caret() {
|
||||
return caret;
|
||||
},
|
||||
pop() {
|
||||
stack.pop();
|
||||
caret = Caret.afterValue;
|
||||
return true;
|
||||
},
|
||||
push(type, newCaret) {
|
||||
stack.push(type);
|
||||
caret = newCaret;
|
||||
return true;
|
||||
},
|
||||
update(newCaret) {
|
||||
caret = newCaret;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
}
|
||||
function last(array) {
|
||||
return array[array.length - 1];
|
||||
}
|
||||
//# sourceMappingURL=stack.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/streaming/stack.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/streaming/stack.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"stack.js","names":["Caret","exports","StackType","createStack","stack","root","caret","beforeValue","type","last","pop","afterValue","push","newCaret","update","array","length"],"sources":["../../../src/streaming/stack.ts"],"sourcesContent":["export enum Caret {\n beforeValue = 'beforeValue',\n afterValue = 'afterValue',\n beforeKey = 'beforeKey'\n}\n\nexport enum StackType {\n root = 'root',\n object = 'object',\n array = 'array',\n ndJson = 'ndJson',\n functionCall = 'dataType'\n}\n\nexport function createStack() {\n const stack: StackType[] = [StackType.root]\n let caret = Caret.beforeValue\n\n return {\n get type() {\n return last(stack)\n },\n\n get caret() {\n return caret\n },\n\n pop(): true {\n stack.pop()\n caret = Caret.afterValue\n\n return true\n },\n\n push(type: StackType, newCaret: Caret): true {\n stack.push(type)\n caret = newCaret\n\n return true\n },\n\n update(newCaret: Caret): true {\n caret = newCaret\n\n return true\n }\n }\n}\n\nfunction last<T>(array: T[]): T | undefined {\n return array[array.length - 1]\n}\n"],"mappings":";;;;;;;IAAYA,KAAK,GAAAC,OAAA,CAAAD,KAAA,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA;AAAA,IAMLE,SAAS,GAAAD,OAAA,CAAAC,SAAA,0BAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAAA,OAATA,SAAS;AAAA;AAQd,SAASC,WAAWA,CAAA,EAAG;EAC5B,MAAMC,KAAkB,GAAG,CAACF,SAAS,CAACG,IAAI,CAAC;EAC3C,IAAIC,KAAK,GAAGN,KAAK,CAACO,WAAW;EAE7B,OAAO;IACL,IAAIC,IAAIA,CAAA,EAAG;MACT,OAAOC,IAAI,CAACL,KAAK,CAAC;IACpB,CAAC;IAED,IAAIE,KAAKA,CAAA,EAAG;MACV,OAAOA,KAAK;IACd,CAAC;IAEDI,GAAGA,CAAA,EAAS;MACVN,KAAK,CAACM,GAAG,CAAC,CAAC;MACXJ,KAAK,GAAGN,KAAK,CAACW,UAAU;MAExB,OAAO,IAAI;IACb,CAAC;IAEDC,IAAIA,CAACJ,IAAe,EAAEK,QAAe,EAAQ;MAC3CT,KAAK,CAACQ,IAAI,CAACJ,IAAI,CAAC;MAChBF,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb,CAAC;IAEDC,MAAMA,CAACD,QAAe,EAAQ;MAC5BP,KAAK,GAAGO,QAAQ;MAEhB,OAAO,IAAI;IACb;EACF,CAAC;AACH;AAEA,SAASJ,IAAIA,CAAIM,KAAU,EAAiB;EAC1C,OAAOA,KAAK,CAACA,KAAK,CAACC,MAAM,GAAG,CAAC,CAAC;AAChC","ignoreList":[]}
|
||||
37
node_modules/jsonrepair/lib/cjs/streaming/stream.js
generated
vendored
Normal file
37
node_modules/jsonrepair/lib/cjs/streaming/stream.js
generated
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.jsonrepairTransform = jsonrepairTransform;
|
||||
var _nodeStream = require("node:stream");
|
||||
var _core = require("./core.js");
|
||||
function jsonrepairTransform(options) {
|
||||
const repair = (0, _core.jsonrepairCore)({
|
||||
onData: chunk => transform.push(chunk),
|
||||
bufferSize: options?.bufferSize,
|
||||
chunkSize: options?.chunkSize
|
||||
});
|
||||
const transform = new _nodeStream.Transform({
|
||||
transform(chunk, _encoding, callback) {
|
||||
try {
|
||||
repair.transform(chunk.toString());
|
||||
} catch (err) {
|
||||
this.emit('error', err);
|
||||
} finally {
|
||||
callback();
|
||||
}
|
||||
},
|
||||
flush(callback) {
|
||||
try {
|
||||
repair.flush();
|
||||
} catch (err) {
|
||||
this.emit('error', err);
|
||||
} finally {
|
||||
callback();
|
||||
}
|
||||
}
|
||||
});
|
||||
return transform;
|
||||
}
|
||||
//# sourceMappingURL=stream.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/streaming/stream.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/streaming/stream.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"stream.js","names":["_nodeStream","require","_core","jsonrepairTransform","options","repair","jsonrepairCore","onData","chunk","transform","push","bufferSize","chunkSize","Transform","_encoding","callback","toString","err","emit","flush"],"sources":["../../../src/streaming/stream.ts"],"sourcesContent":["import { Transform } from 'node:stream'\nimport { jsonrepairCore } from './core.js'\n\nexport interface JsonRepairTransformOptions {\n chunkSize?: number\n bufferSize?: number\n}\n\nexport function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform {\n const repair = jsonrepairCore({\n onData: (chunk) => transform.push(chunk),\n bufferSize: options?.bufferSize,\n chunkSize: options?.chunkSize\n })\n\n const transform = new Transform({\n transform(chunk, _encoding, callback) {\n try {\n repair.transform(chunk.toString())\n } catch (err) {\n this.emit('error', err)\n } finally {\n callback()\n }\n },\n\n flush(callback) {\n try {\n repair.flush()\n } catch (err) {\n this.emit('error', err)\n } finally {\n callback()\n }\n }\n })\n\n return transform\n}\n"],"mappings":";;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAD,OAAA;AAOO,SAASE,mBAAmBA,CAACC,OAAoC,EAAa;EACnF,MAAMC,MAAM,GAAG,IAAAC,oBAAc,EAAC;IAC5BC,MAAM,EAAGC,KAAK,IAAKC,SAAS,CAACC,IAAI,CAACF,KAAK,CAAC;IACxCG,UAAU,EAAEP,OAAO,EAAEO,UAAU;IAC/BC,SAAS,EAAER,OAAO,EAAEQ;EACtB,CAAC,CAAC;EAEF,MAAMH,SAAS,GAAG,IAAII,qBAAS,CAAC;IAC9BJ,SAASA,CAACD,KAAK,EAAEM,SAAS,EAAEC,QAAQ,EAAE;MACpC,IAAI;QACFV,MAAM,CAACI,SAAS,CAACD,KAAK,CAACQ,QAAQ,CAAC,CAAC,CAAC;MACpC,CAAC,CAAC,OAAOC,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF,CAAC;IAEDI,KAAKA,CAACJ,QAAQ,EAAE;MACd,IAAI;QACFV,MAAM,CAACc,KAAK,CAAC,CAAC;MAChB,CAAC,CAAC,OAAOF,GAAG,EAAE;QACZ,IAAI,CAACC,IAAI,CAAC,OAAO,EAAED,GAAG,CAAC;MACzB,CAAC,SAAS;QACRF,QAAQ,CAAC,CAAC;MACZ;IACF;EACF,CAAC,CAAC;EAEF,OAAON,SAAS;AAClB","ignoreList":[]}
|
||||
14
node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js
generated
vendored
Normal file
14
node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.JSONRepairError = void 0;
|
||||
class JSONRepairError extends Error {
|
||||
constructor(message, position) {
|
||||
super(`${message} at position ${position}`);
|
||||
this.position = position;
|
||||
}
|
||||
}
|
||||
exports.JSONRepairError = JSONRepairError;
|
||||
//# sourceMappingURL=JSONRepairError.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/utils/JSONRepairError.js.map
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
{"version":3,"file":"JSONRepairError.js","names":["JSONRepairError","Error","constructor","message","position","exports"],"sources":["../../../src/utils/JSONRepairError.ts"],"sourcesContent":["export class JSONRepairError extends Error {\n position: number\n\n constructor(message: string, position: number) {\n super(`${message} at position ${position}`)\n\n this.position = position\n }\n}\n"],"mappings":";;;;;;AAAO,MAAMA,eAAe,SAASC,KAAK,CAAC;EAGzCC,WAAWA,CAACC,OAAe,EAAEC,QAAgB,EAAE;IAC7C,KAAK,CAAC,GAAGD,OAAO,gBAAgBC,QAAQ,EAAE,CAAC;IAE3C,IAAI,CAACA,QAAQ,GAAGA,QAAQ;EAC1B;AACF;AAACC,OAAA,CAAAL,eAAA,GAAAA,eAAA","ignoreList":[]}
|
||||
174
node_modules/jsonrepair/lib/cjs/utils/stringUtils.js
generated
vendored
Normal file
174
node_modules/jsonrepair/lib/cjs/utils/stringUtils.js
generated
vendored
Normal file
@ -0,0 +1,174 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.endsWithCommaOrNewline = endsWithCommaOrNewline;
|
||||
exports.insertBeforeLastWhitespace = insertBeforeLastWhitespace;
|
||||
exports.isControlCharacter = isControlCharacter;
|
||||
exports.isDelimiter = isDelimiter;
|
||||
exports.isDigit = isDigit;
|
||||
exports.isDoubleQuote = isDoubleQuote;
|
||||
exports.isDoubleQuoteLike = isDoubleQuoteLike;
|
||||
exports.isFunctionNameChar = isFunctionNameChar;
|
||||
exports.isFunctionNameCharStart = isFunctionNameCharStart;
|
||||
exports.isHex = isHex;
|
||||
exports.isQuote = isQuote;
|
||||
exports.isSingleQuote = isSingleQuote;
|
||||
exports.isSingleQuoteLike = isSingleQuoteLike;
|
||||
exports.isSpecialWhitespace = isSpecialWhitespace;
|
||||
exports.isStartOfValue = isStartOfValue;
|
||||
exports.isUnquotedStringDelimiter = isUnquotedStringDelimiter;
|
||||
exports.isValidStringCharacter = isValidStringCharacter;
|
||||
exports.isWhitespace = isWhitespace;
|
||||
exports.isWhitespaceExceptNewline = isWhitespaceExceptNewline;
|
||||
exports.regexUrlStart = exports.regexUrlChar = void 0;
|
||||
exports.removeAtIndex = removeAtIndex;
|
||||
exports.stripLastOccurrence = stripLastOccurrence;
|
||||
const codeSpace = 0x20; // " "
|
||||
const codeNewline = 0xa; // "\n"
|
||||
const codeTab = 0x9; // "\t"
|
||||
const codeReturn = 0xd; // "\r"
|
||||
const codeNonBreakingSpace = 0xa0;
|
||||
const codeEnQuad = 0x2000;
|
||||
const codeHairSpace = 0x200a;
|
||||
const codeNarrowNoBreakSpace = 0x202f;
|
||||
const codeMediumMathematicalSpace = 0x205f;
|
||||
const codeIdeographicSpace = 0x3000;
|
||||
function isHex(char) {
|
||||
return /^[0-9A-Fa-f]$/.test(char);
|
||||
}
|
||||
function isDigit(char) {
|
||||
return char >= '0' && char <= '9';
|
||||
}
|
||||
function isValidStringCharacter(char) {
|
||||
// note that the valid range is between \u{0020} and \u{10ffff},
|
||||
// but in JavaScript it is not possible to create a code point larger than
|
||||
// \u{10ffff}, so there is no need to test for that here.
|
||||
return char >= '\u0020';
|
||||
}
|
||||
function isDelimiter(char) {
|
||||
return ',:[]/{}()\n+'.includes(char);
|
||||
}
|
||||
function isFunctionNameCharStart(char) {
|
||||
return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$';
|
||||
}
|
||||
function isFunctionNameChar(char) {
|
||||
return char >= 'a' && char <= 'z' || char >= 'A' && char <= 'Z' || char === '_' || char === '$' || char >= '0' && char <= '9';
|
||||
}
|
||||
|
||||
// matches "https://" and other schemas
|
||||
const regexUrlStart = exports.regexUrlStart = /^(http|https|ftp|mailto|file|data|irc):\/\/$/;
|
||||
|
||||
// matches all valid URL characters EXCEPT "[", "]", and ",", since that are important JSON delimiters
|
||||
const regexUrlChar = exports.regexUrlChar = /^[A-Za-z0-9-._~:/?#@!$&'()*+;=]$/;
|
||||
function isUnquotedStringDelimiter(char) {
|
||||
return ',[]/{}\n+'.includes(char);
|
||||
}
|
||||
function isStartOfValue(char) {
|
||||
return isQuote(char) || regexStartOfValue.test(char);
|
||||
}
|
||||
|
||||
// alpha, number, minus, or opening bracket or brace
|
||||
const regexStartOfValue = /^[[{\w-]$/;
|
||||
function isControlCharacter(char) {
|
||||
return char === '\n' || char === '\r' || char === '\t' || char === '\b' || char === '\f';
|
||||
}
|
||||
/**
|
||||
* Check if the given character is a whitespace character like space, tab, or
|
||||
* newline
|
||||
*/
|
||||
function isWhitespace(text, index) {
|
||||
const code = text.charCodeAt(index);
|
||||
return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the given character is a whitespace character like space or tab,
|
||||
* but NOT a newline
|
||||
*/
|
||||
function isWhitespaceExceptNewline(text, index) {
|
||||
const code = text.charCodeAt(index);
|
||||
return code === codeSpace || code === codeTab || code === codeReturn;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the given character is a special whitespace character, some
|
||||
* unicode variant
|
||||
*/
|
||||
function isSpecialWhitespace(text, index) {
|
||||
const code = text.charCodeAt(index);
|
||||
return code === codeNonBreakingSpace || code >= codeEnQuad && code <= codeHairSpace || code === codeNarrowNoBreakSpace || code === codeMediumMathematicalSpace || code === codeIdeographicSpace;
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether the given character is a quote or double quote character.
|
||||
* Also tests for special variants of quotes.
|
||||
*/
|
||||
function isQuote(char) {
|
||||
// the first check double quotes, since that occurs most often
|
||||
return isDoubleQuoteLike(char) || isSingleQuoteLike(char);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether the given character is a double quote character.
|
||||
* Also tests for special variants of double quotes.
|
||||
*/
|
||||
function isDoubleQuoteLike(char) {
|
||||
return char === '"' || char === '\u201c' || char === '\u201d';
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether the given character is a double quote character.
|
||||
* Does NOT test for special variants of double quotes.
|
||||
*/
|
||||
function isDoubleQuote(char) {
|
||||
return char === '"';
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether the given character is a single quote character.
|
||||
* Also tests for special variants of single quotes.
|
||||
*/
|
||||
function isSingleQuoteLike(char) {
|
||||
return char === "'" || char === '\u2018' || char === '\u2019' || char === '\u0060' || char === '\u00b4';
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether the given character is a single quote character.
|
||||
* Does NOT test for special variants of single quotes.
|
||||
*/
|
||||
function isSingleQuote(char) {
|
||||
return char === "'";
|
||||
}
|
||||
|
||||
/**
|
||||
* Strip last occurrence of textToStrip from text
|
||||
*/
|
||||
function stripLastOccurrence(text, textToStrip) {
|
||||
let stripRemainingText = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
|
||||
const index = text.lastIndexOf(textToStrip);
|
||||
return index !== -1 ? text.substring(0, index) + (stripRemainingText ? '' : text.substring(index + 1)) : text;
|
||||
}
|
||||
function insertBeforeLastWhitespace(text, textToInsert) {
|
||||
let index = text.length;
|
||||
if (!isWhitespace(text, index - 1)) {
|
||||
// no trailing whitespaces
|
||||
return text + textToInsert;
|
||||
}
|
||||
while (isWhitespace(text, index - 1)) {
|
||||
index--;
|
||||
}
|
||||
return text.substring(0, index) + textToInsert + text.substring(index);
|
||||
}
|
||||
function removeAtIndex(text, start, count) {
|
||||
return text.substring(0, start) + text.substring(start + count);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether a string ends with a newline or comma character and optional whitespace
|
||||
*/
|
||||
function endsWithCommaOrNewline(text) {
|
||||
return /[,\n][ \t\r]*$/.test(text);
|
||||
}
|
||||
//# sourceMappingURL=stringUtils.js.map
|
||||
1
node_modules/jsonrepair/lib/cjs/utils/stringUtils.js.map
generated
vendored
Normal file
1
node_modules/jsonrepair/lib/cjs/utils/stringUtils.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user