hehaiguang1123
21449 lines
1.6 MiB
Plaintext
21449 lines
1.6 MiB
Plaintext
/*
|
|
THIS IS A GENERATED/BUNDLED FILE BY ROLLUP
|
|
if you want to view the source visit the plugins github repository
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var obsidian = require('obsidian');
|
|
var path = require('path');
|
|
var fs$2 = require('fs');
|
|
var url = require('url');
|
|
|
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
|
|
|
var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
|
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$2);
|
|
|
|
/******************************************************************************
|
|
Copyright (c) Microsoft Corporation.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
***************************************************************************** */
|
|
|
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
}
|
|
|
|
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
|
var e = new Error(message);
|
|
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
};
|
|
|
|
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
|
|
|
function getDefaultExportFromCjs (x) {
|
|
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
|
}
|
|
|
|
function getAugmentedNamespace(n) {
|
|
if (n.__esModule) return n;
|
|
var f = n.default;
|
|
if (typeof f == "function") {
|
|
var a = function a () {
|
|
if (this instanceof a) {
|
|
var args = [null];
|
|
args.push.apply(args, arguments);
|
|
var Ctor = Function.bind.apply(f, args);
|
|
return new Ctor();
|
|
}
|
|
return f.apply(this, arguments);
|
|
};
|
|
a.prototype = f.prototype;
|
|
} else a = {};
|
|
Object.defineProperty(a, '__esModule', {value: true});
|
|
Object.keys(n).forEach(function (k) {
|
|
var d = Object.getOwnPropertyDescriptor(n, k);
|
|
Object.defineProperty(a, k, d.get ? d : {
|
|
enumerable: true,
|
|
get: function () {
|
|
return n[k];
|
|
}
|
|
});
|
|
});
|
|
return a;
|
|
}
|
|
|
|
var lib$3 = {};
|
|
|
|
var FsPromise = {};
|
|
|
|
/**
|
|
* Module convert fs functions to promise based functions
|
|
*/
|
|
Object.defineProperty(FsPromise, "__esModule", { value: true });
|
|
FsPromise.readFile = FsPromise.writeFileSync = FsPromise.writeFile = FsPromise.read = FsPromise.open = FsPromise.close = FsPromise.stat = FsPromise.createReadStream = FsPromise.pathExists = void 0;
|
|
const fs$1 = fs__default["default"];
|
|
FsPromise.pathExists = fs$1.existsSync;
|
|
FsPromise.createReadStream = fs$1.createReadStream;
|
|
async function stat(path) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.stat(path, (err, stats) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(stats);
|
|
});
|
|
});
|
|
}
|
|
FsPromise.stat = stat;
|
|
async function close(fd) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.close(fd, err => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
FsPromise.close = close;
|
|
async function open(path, mode) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.open(path, mode, (err, fd) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(fd);
|
|
});
|
|
});
|
|
}
|
|
FsPromise.open = open;
|
|
async function read(fd, buffer, offset, length, position) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.read(fd, buffer, offset, length, position, (err, bytesRead, _buffer) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve({ bytesRead, buffer: _buffer });
|
|
});
|
|
});
|
|
}
|
|
FsPromise.read = read;
|
|
async function writeFile(path, data) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.writeFile(path, data, err => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
FsPromise.writeFile = writeFile;
|
|
function writeFileSync(path, data) {
|
|
fs$1.writeFileSync(path, data);
|
|
}
|
|
FsPromise.writeFileSync = writeFileSync;
|
|
async function readFile(path) {
|
|
return new Promise((resolve, reject) => {
|
|
fs$1.readFile(path, (err, buffer) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(buffer);
|
|
});
|
|
});
|
|
}
|
|
FsPromise.readFile = readFile;
|
|
|
|
var core$3 = {};
|
|
|
|
var ReadStreamTokenizer$1 = {};
|
|
|
|
var AbstractTokenizer$1 = {};
|
|
|
|
var lib$2 = {};
|
|
|
|
var EndOfFileStream = {};
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.EndOfStreamError = exports.defaultMessages = void 0;
|
|
exports.defaultMessages = 'End-Of-Stream';
|
|
/**
|
|
* Thrown on read operation of the end of file or stream has been reached
|
|
*/
|
|
class EndOfStreamError extends Error {
|
|
constructor() {
|
|
super(exports.defaultMessages);
|
|
}
|
|
}
|
|
exports.EndOfStreamError = EndOfStreamError;
|
|
} (EndOfFileStream));
|
|
|
|
var StreamReader = {};
|
|
|
|
var Deferred$1 = {};
|
|
|
|
Object.defineProperty(Deferred$1, "__esModule", { value: true });
|
|
Deferred$1.Deferred = void 0;
|
|
class Deferred {
|
|
constructor() {
|
|
this.resolve = () => null;
|
|
this.reject = () => null;
|
|
this.promise = new Promise((resolve, reject) => {
|
|
this.reject = reject;
|
|
this.resolve = resolve;
|
|
});
|
|
}
|
|
}
|
|
Deferred$1.Deferred = Deferred;
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.StreamReader = exports.EndOfStreamError = void 0;
|
|
const EndOfFileStream_1 = EndOfFileStream;
|
|
const Deferred_1 = Deferred$1;
|
|
var EndOfFileStream_2 = EndOfFileStream;
|
|
Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function () { return EndOfFileStream_2.EndOfStreamError; } });
|
|
const maxStreamReadSize = 1 * 1024 * 1024; // Maximum request length on read-stream operation
|
|
class StreamReader {
|
|
constructor(s) {
|
|
this.s = s;
|
|
/**
|
|
* Deferred used for postponed read request (as not data is yet available to read)
|
|
*/
|
|
this.deferred = null;
|
|
this.endOfStream = false;
|
|
/**
|
|
* Store peeked data
|
|
* @type {Array}
|
|
*/
|
|
this.peekQueue = [];
|
|
if (!s.read || !s.once) {
|
|
throw new Error('Expected an instance of stream.Readable');
|
|
}
|
|
this.s.once('end', () => this.reject(new EndOfFileStream_1.EndOfStreamError()));
|
|
this.s.once('error', err => this.reject(err));
|
|
this.s.once('close', () => this.reject(new Error('Stream closed')));
|
|
}
|
|
/**
|
|
* Read ahead (peek) from stream. Subsequent read or peeks will return the same data
|
|
* @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
|
|
* @param offset - Offset target
|
|
* @param length - Number of bytes to read
|
|
* @returns Number of bytes peeked
|
|
*/
|
|
async peek(uint8Array, offset, length) {
|
|
const bytesRead = await this.read(uint8Array, offset, length);
|
|
this.peekQueue.push(uint8Array.subarray(offset, offset + bytesRead)); // Put read data back to peek buffer
|
|
return bytesRead;
|
|
}
|
|
/**
|
|
* Read chunk from stream
|
|
* @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
|
|
* @param offset - Offset target
|
|
* @param length - Number of bytes to read
|
|
* @returns Number of bytes read
|
|
*/
|
|
async read(buffer, offset, length) {
|
|
if (length === 0) {
|
|
return 0;
|
|
}
|
|
if (this.peekQueue.length === 0 && this.endOfStream) {
|
|
throw new EndOfFileStream_1.EndOfStreamError();
|
|
}
|
|
let remaining = length;
|
|
let bytesRead = 0;
|
|
// consume peeked data first
|
|
while (this.peekQueue.length > 0 && remaining > 0) {
|
|
const peekData = this.peekQueue.pop(); // Front of queue
|
|
if (!peekData)
|
|
throw new Error('peekData should be defined');
|
|
const lenCopy = Math.min(peekData.length, remaining);
|
|
buffer.set(peekData.subarray(0, lenCopy), offset + bytesRead);
|
|
bytesRead += lenCopy;
|
|
remaining -= lenCopy;
|
|
if (lenCopy < peekData.length) {
|
|
// remainder back to queue
|
|
this.peekQueue.push(peekData.subarray(lenCopy));
|
|
}
|
|
}
|
|
// continue reading from stream if required
|
|
while (remaining > 0 && !this.endOfStream) {
|
|
const reqLen = Math.min(remaining, maxStreamReadSize);
|
|
const chunkLen = await this.readFromStream(buffer, offset + bytesRead, reqLen);
|
|
bytesRead += chunkLen;
|
|
if (chunkLen < reqLen)
|
|
break;
|
|
remaining -= chunkLen;
|
|
}
|
|
return bytesRead;
|
|
}
|
|
/**
|
|
* Read chunk from stream
|
|
* @param buffer Target Uint8Array (or Buffer) to store data read from stream in
|
|
* @param offset Offset target
|
|
* @param length Number of bytes to read
|
|
* @returns Number of bytes read
|
|
*/
|
|
async readFromStream(buffer, offset, length) {
|
|
const readBuffer = this.s.read(length);
|
|
if (readBuffer) {
|
|
buffer.set(readBuffer, offset);
|
|
return readBuffer.length;
|
|
}
|
|
else {
|
|
const request = {
|
|
buffer,
|
|
offset,
|
|
length,
|
|
deferred: new Deferred_1.Deferred()
|
|
};
|
|
this.deferred = request.deferred;
|
|
this.s.once('readable', () => {
|
|
this.readDeferred(request);
|
|
});
|
|
return request.deferred.promise;
|
|
}
|
|
}
|
|
/**
|
|
* Process deferred read request
|
|
* @param request Deferred read request
|
|
*/
|
|
readDeferred(request) {
|
|
const readBuffer = this.s.read(request.length);
|
|
if (readBuffer) {
|
|
request.buffer.set(readBuffer, request.offset);
|
|
request.deferred.resolve(readBuffer.length);
|
|
this.deferred = null;
|
|
}
|
|
else {
|
|
this.s.once('readable', () => {
|
|
this.readDeferred(request);
|
|
});
|
|
}
|
|
}
|
|
reject(err) {
|
|
this.endOfStream = true;
|
|
if (this.deferred) {
|
|
this.deferred.reject(err);
|
|
this.deferred = null;
|
|
}
|
|
}
|
|
}
|
|
exports.StreamReader = StreamReader;
|
|
} (StreamReader));
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.StreamReader = exports.EndOfStreamError = void 0;
|
|
var EndOfFileStream_1 = EndOfFileStream;
|
|
Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function () { return EndOfFileStream_1.EndOfStreamError; } });
|
|
var StreamReader_1 = StreamReader;
|
|
Object.defineProperty(exports, "StreamReader", { enumerable: true, get: function () { return StreamReader_1.StreamReader; } });
|
|
} (lib$2));
|
|
|
|
Object.defineProperty(AbstractTokenizer$1, "__esModule", { value: true });
|
|
AbstractTokenizer$1.AbstractTokenizer = void 0;
|
|
const peek_readable_1$3 = lib$2;
|
|
/**
|
|
* Core tokenizer
|
|
*/
|
|
class AbstractTokenizer {
|
|
constructor(fileInfo) {
|
|
/**
|
|
* Tokenizer-stream position
|
|
*/
|
|
this.position = 0;
|
|
this.numBuffer = new Uint8Array(8);
|
|
this.fileInfo = fileInfo ? fileInfo : {};
|
|
}
|
|
/**
|
|
* Read a token from the tokenizer-stream
|
|
* @param token - The token to read
|
|
* @param position - If provided, the desired position in the tokenizer-stream
|
|
* @returns Promise with token data
|
|
*/
|
|
async readToken(token, position = this.position) {
|
|
const uint8Array = Buffer.alloc(token.len);
|
|
const len = await this.readBuffer(uint8Array, { position });
|
|
if (len < token.len)
|
|
throw new peek_readable_1$3.EndOfStreamError();
|
|
return token.get(uint8Array, 0);
|
|
}
|
|
/**
|
|
* Peek a token from the tokenizer-stream.
|
|
* @param token - Token to peek from the tokenizer-stream.
|
|
* @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
|
|
* @returns Promise with token data
|
|
*/
|
|
async peekToken(token, position = this.position) {
|
|
const uint8Array = Buffer.alloc(token.len);
|
|
const len = await this.peekBuffer(uint8Array, { position });
|
|
if (len < token.len)
|
|
throw new peek_readable_1$3.EndOfStreamError();
|
|
return token.get(uint8Array, 0);
|
|
}
|
|
/**
|
|
* Read a numeric token from the stream
|
|
* @param token - Numeric token
|
|
* @returns Promise with number
|
|
*/
|
|
async readNumber(token) {
|
|
const len = await this.readBuffer(this.numBuffer, { length: token.len });
|
|
if (len < token.len)
|
|
throw new peek_readable_1$3.EndOfStreamError();
|
|
return token.get(this.numBuffer, 0);
|
|
}
|
|
/**
|
|
* Read a numeric token from the stream
|
|
* @param token - Numeric token
|
|
* @returns Promise with number
|
|
*/
|
|
async peekNumber(token) {
|
|
const len = await this.peekBuffer(this.numBuffer, { length: token.len });
|
|
if (len < token.len)
|
|
throw new peek_readable_1$3.EndOfStreamError();
|
|
return token.get(this.numBuffer, 0);
|
|
}
|
|
/**
|
|
* Ignore number of bytes, advances the pointer in under tokenizer-stream.
|
|
* @param length - Number of bytes to ignore
|
|
* @return resolves the number of bytes ignored, equals length if this available, otherwise the number of bytes available
|
|
*/
|
|
async ignore(length) {
|
|
if (this.fileInfo.size !== undefined) {
|
|
const bytesLeft = this.fileInfo.size - this.position;
|
|
if (length > bytesLeft) {
|
|
this.position += bytesLeft;
|
|
return bytesLeft;
|
|
}
|
|
}
|
|
this.position += length;
|
|
return length;
|
|
}
|
|
async close() {
|
|
// empty
|
|
}
|
|
normalizeOptions(uint8Array, options) {
|
|
if (options && options.position !== undefined && options.position < this.position) {
|
|
throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
|
|
}
|
|
if (options) {
|
|
return {
|
|
mayBeLess: options.mayBeLess === true,
|
|
offset: options.offset ? options.offset : 0,
|
|
length: options.length ? options.length : (uint8Array.length - (options.offset ? options.offset : 0)),
|
|
position: options.position ? options.position : this.position
|
|
};
|
|
}
|
|
return {
|
|
mayBeLess: false,
|
|
offset: 0,
|
|
length: uint8Array.length,
|
|
position: this.position
|
|
};
|
|
}
|
|
}
|
|
AbstractTokenizer$1.AbstractTokenizer = AbstractTokenizer;
|
|
|
|
Object.defineProperty(ReadStreamTokenizer$1, "__esModule", { value: true });
|
|
ReadStreamTokenizer$1.ReadStreamTokenizer = void 0;
|
|
const AbstractTokenizer_1$2 = AbstractTokenizer$1;
|
|
const peek_readable_1$2 = lib$2;
|
|
const maxBufferSize = 256000;
|
|
class ReadStreamTokenizer extends AbstractTokenizer_1$2.AbstractTokenizer {
|
|
constructor(stream, fileInfo) {
|
|
super(fileInfo);
|
|
this.streamReader = new peek_readable_1$2.StreamReader(stream);
|
|
}
|
|
/**
|
|
* Get file information, an HTTP-client may implement this doing a HEAD request
|
|
* @return Promise with file information
|
|
*/
|
|
async getFileInfo() {
|
|
return this.fileInfo;
|
|
}
|
|
/**
|
|
* Read buffer from tokenizer
|
|
* @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
|
|
* @param options - Read behaviour options
|
|
* @returns Promise with number of bytes read
|
|
*/
|
|
async readBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
const skipBytes = normOptions.position - this.position;
|
|
if (skipBytes > 0) {
|
|
await this.ignore(skipBytes);
|
|
return this.readBuffer(uint8Array, options);
|
|
}
|
|
else if (skipBytes < 0) {
|
|
throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
|
|
}
|
|
if (normOptions.length === 0) {
|
|
return 0;
|
|
}
|
|
const bytesRead = await this.streamReader.read(uint8Array, normOptions.offset, normOptions.length);
|
|
this.position += bytesRead;
|
|
if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) {
|
|
throw new peek_readable_1$2.EndOfStreamError();
|
|
}
|
|
return bytesRead;
|
|
}
|
|
/**
|
|
* Peek (read ahead) buffer from tokenizer
|
|
* @param uint8Array - Uint8Array (or Buffer) to write data to
|
|
* @param options - Read behaviour options
|
|
* @returns Promise with number of bytes peeked
|
|
*/
|
|
async peekBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
let bytesRead = 0;
|
|
if (normOptions.position) {
|
|
const skipBytes = normOptions.position - this.position;
|
|
if (skipBytes > 0) {
|
|
const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
|
|
bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
|
|
uint8Array.set(skipBuffer.subarray(skipBytes), normOptions.offset);
|
|
return bytesRead - skipBytes;
|
|
}
|
|
else if (skipBytes < 0) {
|
|
throw new Error('Cannot peek from a negative offset in a stream');
|
|
}
|
|
}
|
|
if (normOptions.length > 0) {
|
|
try {
|
|
bytesRead = await this.streamReader.peek(uint8Array, normOptions.offset, normOptions.length);
|
|
}
|
|
catch (err) {
|
|
if (options && options.mayBeLess && err instanceof peek_readable_1$2.EndOfStreamError) {
|
|
return 0;
|
|
}
|
|
throw err;
|
|
}
|
|
if ((!normOptions.mayBeLess) && bytesRead < normOptions.length) {
|
|
throw new peek_readable_1$2.EndOfStreamError();
|
|
}
|
|
}
|
|
return bytesRead;
|
|
}
|
|
async ignore(length) {
|
|
// debug(`ignore ${this.position}...${this.position + length - 1}`);
|
|
const bufSize = Math.min(maxBufferSize, length);
|
|
const buf = new Uint8Array(bufSize);
|
|
let totBytesRead = 0;
|
|
while (totBytesRead < length) {
|
|
const remaining = length - totBytesRead;
|
|
const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
|
|
if (bytesRead < 0) {
|
|
return bytesRead;
|
|
}
|
|
totBytesRead += bytesRead;
|
|
}
|
|
return totBytesRead;
|
|
}
|
|
}
|
|
ReadStreamTokenizer$1.ReadStreamTokenizer = ReadStreamTokenizer;
|
|
|
|
var BufferTokenizer$1 = {};
|
|
|
|
Object.defineProperty(BufferTokenizer$1, "__esModule", { value: true });
|
|
BufferTokenizer$1.BufferTokenizer = void 0;
|
|
const peek_readable_1$1 = lib$2;
|
|
const AbstractTokenizer_1$1 = AbstractTokenizer$1;
|
|
class BufferTokenizer extends AbstractTokenizer_1$1.AbstractTokenizer {
|
|
/**
|
|
* Construct BufferTokenizer
|
|
* @param uint8Array - Uint8Array to tokenize
|
|
* @param fileInfo - Pass additional file information to the tokenizer
|
|
*/
|
|
constructor(uint8Array, fileInfo) {
|
|
super(fileInfo);
|
|
this.uint8Array = uint8Array;
|
|
this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : uint8Array.length;
|
|
}
|
|
/**
|
|
* Read buffer from tokenizer
|
|
* @param uint8Array - Uint8Array to tokenize
|
|
* @param options - Read behaviour options
|
|
* @returns {Promise<number>}
|
|
*/
|
|
async readBuffer(uint8Array, options) {
|
|
if (options && options.position) {
|
|
if (options.position < this.position) {
|
|
throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
|
|
}
|
|
this.position = options.position;
|
|
}
|
|
const bytesRead = await this.peekBuffer(uint8Array, options);
|
|
this.position += bytesRead;
|
|
return bytesRead;
|
|
}
|
|
/**
|
|
* Peek (read ahead) buffer from tokenizer
|
|
* @param uint8Array
|
|
* @param options - Read behaviour options
|
|
* @returns {Promise<number>}
|
|
*/
|
|
async peekBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
|
|
if ((!normOptions.mayBeLess) && bytes2read < normOptions.length) {
|
|
throw new peek_readable_1$1.EndOfStreamError();
|
|
}
|
|
else {
|
|
uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read), normOptions.offset);
|
|
return bytes2read;
|
|
}
|
|
}
|
|
async close() {
|
|
// empty
|
|
}
|
|
}
|
|
BufferTokenizer$1.BufferTokenizer = BufferTokenizer;
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.fromBuffer = exports.fromStream = exports.EndOfStreamError = void 0;
|
|
const ReadStreamTokenizer_1 = ReadStreamTokenizer$1;
|
|
const BufferTokenizer_1 = BufferTokenizer$1;
|
|
var peek_readable_1 = lib$2;
|
|
Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function () { return peek_readable_1.EndOfStreamError; } });
|
|
/**
|
|
* Construct ReadStreamTokenizer from given Stream.
|
|
* Will set fileSize, if provided given Stream has set the .path property/
|
|
* @param stream - Read from Node.js Stream.Readable
|
|
* @param fileInfo - Pass the file information, like size and MIME-type of the corresponding stream.
|
|
* @returns ReadStreamTokenizer
|
|
*/
|
|
function fromStream(stream, fileInfo) {
|
|
fileInfo = fileInfo ? fileInfo : {};
|
|
return new ReadStreamTokenizer_1.ReadStreamTokenizer(stream, fileInfo);
|
|
}
|
|
exports.fromStream = fromStream;
|
|
/**
|
|
* Construct ReadStreamTokenizer from given Buffer.
|
|
* @param uint8Array - Uint8Array to tokenize
|
|
* @param fileInfo - Pass additional file information to the tokenizer
|
|
* @returns BufferTokenizer
|
|
*/
|
|
function fromBuffer(uint8Array, fileInfo) {
|
|
return new BufferTokenizer_1.BufferTokenizer(uint8Array, fileInfo);
|
|
}
|
|
exports.fromBuffer = fromBuffer;
|
|
} (core$3));
|
|
|
|
var FileTokenizer$1 = {};
|
|
|
|
Object.defineProperty(FileTokenizer$1, "__esModule", { value: true });
|
|
FileTokenizer$1.fromFile = FileTokenizer$1.FileTokenizer = void 0;
|
|
const AbstractTokenizer_1 = AbstractTokenizer$1;
|
|
const peek_readable_1 = lib$2;
|
|
const fs = FsPromise;
|
|
class FileTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
|
|
constructor(fd, fileInfo) {
|
|
super(fileInfo);
|
|
this.fd = fd;
|
|
}
|
|
/**
|
|
* Read buffer from file
|
|
* @param uint8Array - Uint8Array to write result to
|
|
* @param options - Read behaviour options
|
|
* @returns Promise number of bytes read
|
|
*/
|
|
async readBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
this.position = normOptions.position;
|
|
const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
|
|
this.position += res.bytesRead;
|
|
if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
|
|
throw new peek_readable_1.EndOfStreamError();
|
|
}
|
|
return res.bytesRead;
|
|
}
|
|
/**
|
|
* Peek buffer from file
|
|
* @param uint8Array - Uint8Array (or Buffer) to write data to
|
|
* @param options - Read behaviour options
|
|
* @returns Promise number of bytes read
|
|
*/
|
|
async peekBuffer(uint8Array, options) {
|
|
const normOptions = this.normalizeOptions(uint8Array, options);
|
|
const res = await fs.read(this.fd, uint8Array, normOptions.offset, normOptions.length, normOptions.position);
|
|
if ((!normOptions.mayBeLess) && res.bytesRead < normOptions.length) {
|
|
throw new peek_readable_1.EndOfStreamError();
|
|
}
|
|
return res.bytesRead;
|
|
}
|
|
async close() {
|
|
return fs.close(this.fd);
|
|
}
|
|
}
|
|
FileTokenizer$1.FileTokenizer = FileTokenizer;
|
|
async function fromFile$1(sourceFilePath) {
|
|
const stat = await fs.stat(sourceFilePath);
|
|
if (!stat.isFile) {
|
|
throw new Error(`File not a file: ${sourceFilePath}`);
|
|
}
|
|
const fd = await fs.open(sourceFilePath, 'r');
|
|
return new FileTokenizer(fd, { path: sourceFilePath, size: stat.size });
|
|
}
|
|
FileTokenizer$1.fromFile = fromFile$1;
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.fromStream = exports.fromBuffer = exports.EndOfStreamError = exports.fromFile = void 0;
|
|
const fs = FsPromise;
|
|
const core = core$3;
|
|
var FileTokenizer_1 = FileTokenizer$1;
|
|
Object.defineProperty(exports, "fromFile", { enumerable: true, get: function () { return FileTokenizer_1.fromFile; } });
|
|
var core_1 = core$3;
|
|
Object.defineProperty(exports, "EndOfStreamError", { enumerable: true, get: function () { return core_1.EndOfStreamError; } });
|
|
Object.defineProperty(exports, "fromBuffer", { enumerable: true, get: function () { return core_1.fromBuffer; } });
|
|
/**
|
|
* Construct ReadStreamTokenizer from given Stream.
|
|
* Will set fileSize, if provided given Stream has set the .path property.
|
|
* @param stream - Node.js Stream.Readable
|
|
* @param fileInfo - Pass additional file information to the tokenizer
|
|
* @returns Tokenizer
|
|
*/
|
|
async function fromStream(stream, fileInfo) {
|
|
fileInfo = fileInfo ? fileInfo : {};
|
|
if (stream.path) {
|
|
const stat = await fs.stat(stream.path);
|
|
fileInfo.path = stream.path;
|
|
fileInfo.size = stat.size;
|
|
}
|
|
return core.fromStream(stream, fileInfo);
|
|
}
|
|
exports.fromStream = fromStream;
|
|
} (lib$3));
|
|
|
|
var lib$1 = {};
|
|
|
|
var ieee754 = {};
|
|
|
|
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
|
|
|
ieee754.read = function (buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m;
|
|
var eLen = (nBytes * 8) - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var nBits = -7;
|
|
var i = isLE ? (nBytes - 1) : 0;
|
|
var d = isLE ? -1 : 1;
|
|
var s = buffer[offset + i];
|
|
|
|
i += d;
|
|
|
|
e = s & ((1 << (-nBits)) - 1);
|
|
s >>= (-nBits);
|
|
nBits += eLen;
|
|
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
m = e & ((1 << (-nBits)) - 1);
|
|
e >>= (-nBits);
|
|
nBits += mLen;
|
|
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
if (e === 0) {
|
|
e = 1 - eBias;
|
|
} else if (e === eMax) {
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
|
} else {
|
|
m = m + Math.pow(2, mLen);
|
|
e = e - eBias;
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
|
};
|
|
|
|
ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c;
|
|
var eLen = (nBytes * 8) - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
|
|
var i = isLE ? 0 : (nBytes - 1);
|
|
var d = isLE ? 1 : -1;
|
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
|
|
|
value = Math.abs(value);
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0;
|
|
e = eMax;
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2);
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--;
|
|
c *= 2;
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c;
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias);
|
|
}
|
|
if (value * c >= 2) {
|
|
e++;
|
|
c /= 2;
|
|
}
|
|
|
|
if (e + eBias >= eMax) {
|
|
m = 0;
|
|
e = eMax;
|
|
} else if (e + eBias >= 1) {
|
|
m = ((value * c) - 1) * Math.pow(2, mLen);
|
|
e = e + eBias;
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
|
e = 0;
|
|
}
|
|
}
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
|
|
e = (e << mLen) | m;
|
|
eLen += mLen;
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
|
|
buffer[offset + i - d] |= s * 128;
|
|
};
|
|
|
|
(function (exports) {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.AnsiStringType = exports.StringType = exports.BufferType = exports.Uint8ArrayType = exports.IgnoreType = exports.Float80_LE = exports.Float80_BE = exports.Float64_LE = exports.Float64_BE = exports.Float32_LE = exports.Float32_BE = exports.Float16_LE = exports.Float16_BE = exports.INT64_BE = exports.UINT64_BE = exports.INT64_LE = exports.UINT64_LE = exports.INT32_LE = exports.INT32_BE = exports.INT24_BE = exports.INT24_LE = exports.INT16_LE = exports.INT16_BE = exports.INT8 = exports.UINT32_BE = exports.UINT32_LE = exports.UINT24_BE = exports.UINT24_LE = exports.UINT16_BE = exports.UINT16_LE = exports.UINT8 = void 0;
|
|
const ieee754$1 = ieee754;
|
|
// Primitive types
|
|
function dv(array) {
|
|
return new DataView(array.buffer, array.byteOffset);
|
|
}
|
|
/**
|
|
* 8-bit unsigned integer
|
|
*/
|
|
exports.UINT8 = {
|
|
len: 1,
|
|
get(array, offset) {
|
|
return dv(array).getUint8(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint8(offset, value);
|
|
return offset + 1;
|
|
}
|
|
};
|
|
/**
|
|
* 16-bit unsigned integer, Little Endian byte order
|
|
*/
|
|
exports.UINT16_LE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getUint16(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint16(offset, value, true);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
/**
|
|
* 16-bit unsigned integer, Big Endian byte order
|
|
*/
|
|
exports.UINT16_BE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getUint16(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint16(offset, value);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
/**
|
|
* 24-bit unsigned integer, Little Endian byte order
|
|
*/
|
|
exports.UINT24_LE = {
|
|
len: 3,
|
|
get(array, offset) {
|
|
const dataView = dv(array);
|
|
return dataView.getUint8(offset) + (dataView.getUint16(offset + 1, true) << 8);
|
|
},
|
|
put(array, offset, value) {
|
|
const dataView = dv(array);
|
|
dataView.setUint8(offset, value & 0xff);
|
|
dataView.setUint16(offset + 1, value >> 8, true);
|
|
return offset + 3;
|
|
}
|
|
};
|
|
/**
|
|
* 24-bit unsigned integer, Big Endian byte order
|
|
*/
|
|
exports.UINT24_BE = {
|
|
len: 3,
|
|
get(array, offset) {
|
|
const dataView = dv(array);
|
|
return (dataView.getUint16(offset) << 8) + dataView.getUint8(offset + 2);
|
|
},
|
|
put(array, offset, value) {
|
|
const dataView = dv(array);
|
|
dataView.setUint16(offset, value >> 8);
|
|
dataView.setUint8(offset + 2, value & 0xff);
|
|
return offset + 3;
|
|
}
|
|
};
|
|
/**
|
|
* 32-bit unsigned integer, Little Endian byte order
|
|
*/
|
|
exports.UINT32_LE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getUint32(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint32(offset, value, true);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* 32-bit unsigned integer, Big Endian byte order
|
|
*/
|
|
exports.UINT32_BE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getUint32(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setUint32(offset, value);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* 8-bit signed integer
|
|
*/
|
|
exports.INT8 = {
|
|
len: 1,
|
|
get(array, offset) {
|
|
return dv(array).getInt8(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt8(offset, value);
|
|
return offset + 1;
|
|
}
|
|
};
|
|
/**
|
|
* 16-bit signed integer, Big Endian byte order
|
|
*/
|
|
exports.INT16_BE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getInt16(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt16(offset, value);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
/**
|
|
* 16-bit signed integer, Little Endian byte order
|
|
*/
|
|
exports.INT16_LE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return dv(array).getInt16(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt16(offset, value, true);
|
|
return offset + 2;
|
|
}
|
|
};
|
|
/**
|
|
* 24-bit signed integer, Little Endian byte order
|
|
*/
|
|
exports.INT24_LE = {
|
|
len: 3,
|
|
get(array, offset) {
|
|
const unsigned = exports.UINT24_LE.get(array, offset);
|
|
return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;
|
|
},
|
|
put(array, offset, value) {
|
|
const dataView = dv(array);
|
|
dataView.setUint8(offset, value & 0xff);
|
|
dataView.setUint16(offset + 1, value >> 8, true);
|
|
return offset + 3;
|
|
}
|
|
};
|
|
/**
|
|
* 24-bit signed integer, Big Endian byte order
|
|
*/
|
|
exports.INT24_BE = {
|
|
len: 3,
|
|
get(array, offset) {
|
|
const unsigned = exports.UINT24_BE.get(array, offset);
|
|
return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;
|
|
},
|
|
put(array, offset, value) {
|
|
const dataView = dv(array);
|
|
dataView.setUint16(offset, value >> 8);
|
|
dataView.setUint8(offset + 2, value & 0xff);
|
|
return offset + 3;
|
|
}
|
|
};
|
|
/**
|
|
* 32-bit signed integer, Big Endian byte order
|
|
*/
|
|
exports.INT32_BE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getInt32(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt32(offset, value);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* 32-bit signed integer, Big Endian byte order
|
|
*/
|
|
exports.INT32_LE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getInt32(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setInt32(offset, value, true);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* 64-bit unsigned integer, Little Endian byte order
|
|
*/
|
|
exports.UINT64_LE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getBigUint64(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setBigUint64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* 64-bit signed integer, Little Endian byte order
|
|
*/
|
|
exports.INT64_LE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getBigInt64(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setBigInt64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* 64-bit unsigned integer, Big Endian byte order
|
|
*/
|
|
exports.UINT64_BE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getBigUint64(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setBigUint64(offset, value);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* 64-bit signed integer, Big Endian byte order
|
|
*/
|
|
exports.INT64_BE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getBigInt64(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setBigInt64(offset, value);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 16-bit (half precision) float, big endian
|
|
*/
|
|
exports.Float16_BE = {
|
|
len: 2,
|
|
get(dataView, offset) {
|
|
return ieee754$1.read(dataView, offset, false, 10, this.len);
|
|
},
|
|
put(dataView, offset, value) {
|
|
ieee754$1.write(dataView, value, offset, false, 10, this.len);
|
|
return offset + this.len;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 16-bit (half precision) float, little endian
|
|
*/
|
|
exports.Float16_LE = {
|
|
len: 2,
|
|
get(array, offset) {
|
|
return ieee754$1.read(array, offset, true, 10, this.len);
|
|
},
|
|
put(array, offset, value) {
|
|
ieee754$1.write(array, value, offset, true, 10, this.len);
|
|
return offset + this.len;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 32-bit (single precision) float, big endian
|
|
*/
|
|
exports.Float32_BE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getFloat32(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setFloat32(offset, value);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 32-bit (single precision) float, little endian
|
|
*/
|
|
exports.Float32_LE = {
|
|
len: 4,
|
|
get(array, offset) {
|
|
return dv(array).getFloat32(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setFloat32(offset, value, true);
|
|
return offset + 4;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 64-bit (double precision) float, big endian
|
|
*/
|
|
exports.Float64_BE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getFloat64(offset);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setFloat64(offset, value);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 64-bit (double precision) float, little endian
|
|
*/
|
|
exports.Float64_LE = {
|
|
len: 8,
|
|
get(array, offset) {
|
|
return dv(array).getFloat64(offset, true);
|
|
},
|
|
put(array, offset, value) {
|
|
dv(array).setFloat64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 80-bit (extended precision) float, big endian
|
|
*/
|
|
exports.Float80_BE = {
|
|
len: 10,
|
|
get(array, offset) {
|
|
return ieee754$1.read(array, offset, false, 63, this.len);
|
|
},
|
|
put(array, offset, value) {
|
|
ieee754$1.write(array, value, offset, false, 63, this.len);
|
|
return offset + this.len;
|
|
}
|
|
};
|
|
/**
|
|
* IEEE 754 80-bit (extended precision) float, little endian
|
|
*/
|
|
exports.Float80_LE = {
|
|
len: 10,
|
|
get(array, offset) {
|
|
return ieee754$1.read(array, offset, true, 63, this.len);
|
|
},
|
|
put(array, offset, value) {
|
|
ieee754$1.write(array, value, offset, true, 63, this.len);
|
|
return offset + this.len;
|
|
}
|
|
};
|
|
/**
|
|
* Ignore a given number of bytes
|
|
*/
|
|
class IgnoreType {
|
|
/**
|
|
* @param len number of bytes to ignore
|
|
*/
|
|
constructor(len) {
|
|
this.len = len;
|
|
}
|
|
// ToDo: don't read, but skip data
|
|
get(array, off) {
|
|
}
|
|
}
|
|
exports.IgnoreType = IgnoreType;
|
|
class Uint8ArrayType {
|
|
constructor(len) {
|
|
this.len = len;
|
|
}
|
|
get(array, offset) {
|
|
return array.subarray(offset, offset + this.len);
|
|
}
|
|
}
|
|
exports.Uint8ArrayType = Uint8ArrayType;
|
|
class BufferType {
|
|
constructor(len) {
|
|
this.len = len;
|
|
}
|
|
get(uint8Array, off) {
|
|
return Buffer.from(uint8Array.subarray(off, off + this.len));
|
|
}
|
|
}
|
|
exports.BufferType = BufferType;
|
|
/**
|
|
* Consume a fixed number of bytes from the stream and return a string with a specified encoding.
|
|
*/
|
|
class StringType {
|
|
constructor(len, encoding) {
|
|
this.len = len;
|
|
this.encoding = encoding;
|
|
}
|
|
get(uint8Array, offset) {
|
|
return Buffer.from(uint8Array).toString(this.encoding, offset, offset + this.len);
|
|
}
|
|
}
|
|
exports.StringType = StringType;
|
|
/**
|
|
* ANSI Latin 1 String
|
|
* Using windows-1252 / ISO 8859-1 decoding
|
|
*/
|
|
class AnsiStringType {
|
|
constructor(len) {
|
|
this.len = len;
|
|
}
|
|
static decode(buffer, offset, until) {
|
|
let str = '';
|
|
for (let i = offset; i < until; ++i) {
|
|
str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
|
|
}
|
|
return str;
|
|
}
|
|
static inRange(a, min, max) {
|
|
return min <= a && a <= max;
|
|
}
|
|
static codePointToString(cp) {
|
|
if (cp <= 0xFFFF) {
|
|
return String.fromCharCode(cp);
|
|
}
|
|
else {
|
|
cp -= 0x10000;
|
|
return String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00);
|
|
}
|
|
}
|
|
static singleByteDecoder(bite) {
|
|
if (AnsiStringType.inRange(bite, 0x00, 0x7F)) {
|
|
return bite;
|
|
}
|
|
const codePoint = AnsiStringType.windows1252[bite - 0x80];
|
|
if (codePoint === null) {
|
|
throw Error('invaliding encoding');
|
|
}
|
|
return codePoint;
|
|
}
|
|
get(buffer, offset = 0) {
|
|
return AnsiStringType.decode(buffer, offset, offset + this.len);
|
|
}
|
|
}
|
|
exports.AnsiStringType = AnsiStringType;
|
|
AnsiStringType.windows1252 = [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352,
|
|
8249, 338, 141, 381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732,
|
|
8482, 353, 8250, 339, 157, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168,
|
|
169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
|
|
185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
|
|
201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
|
|
217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
|
|
233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
|
|
248, 249, 250, 251, 252, 253, 254, 255];
|
|
} (lib$1));
|
|
|
|
var util$4 = {};
|
|
|
|
util$4.stringToBytes = string => [...string].map(character => character.charCodeAt(0));
|
|
|
|
/**
|
|
Checks whether the TAR checksum is valid.
|
|
|
|
@param {Buffer} buffer - The TAR header `[offset ... offset + 512]`.
|
|
@param {number} offset - TAR header offset.
|
|
@returns {boolean} `true` if the TAR checksum is valid, otherwise `false`.
|
|
*/
|
|
util$4.tarHeaderChecksumMatches = (buffer, offset = 0) => {
|
|
const readSum = parseInt(buffer.toString('utf8', 148, 154).replace(/\0.*$/, '').trim(), 8); // Read sum in header
|
|
if (isNaN(readSum)) {
|
|
return false;
|
|
}
|
|
|
|
let sum = 8 * 0x20; // Initialize signed bit sum
|
|
|
|
for (let i = offset; i < offset + 148; i++) {
|
|
sum += buffer[i];
|
|
}
|
|
|
|
for (let i = offset + 156; i < offset + 512; i++) {
|
|
sum += buffer[i];
|
|
}
|
|
|
|
return readSum === sum;
|
|
};
|
|
|
|
/**
|
|
ID3 UINT32 sync-safe tokenizer token.
|
|
28 bits (representing up to 256MB) integer, the msb is 0 to avoid "false syncsignals".
|
|
*/
|
|
util$4.uint32SyncSafeToken = {
|
|
get: (buffer, offset) => {
|
|
return (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2]) << 7) | ((buffer[offset + 1]) << 14) | ((buffer[offset]) << 21);
|
|
},
|
|
len: 4
|
|
};
|
|
|
|
var supported$1 = {
|
|
extensions: [
|
|
'jpg',
|
|
'png',
|
|
'apng',
|
|
'gif',
|
|
'webp',
|
|
'flif',
|
|
'xcf',
|
|
'cr2',
|
|
'cr3',
|
|
'orf',
|
|
'arw',
|
|
'dng',
|
|
'nef',
|
|
'rw2',
|
|
'raf',
|
|
'tif',
|
|
'bmp',
|
|
'icns',
|
|
'jxr',
|
|
'psd',
|
|
'indd',
|
|
'zip',
|
|
'tar',
|
|
'rar',
|
|
'gz',
|
|
'bz2',
|
|
'7z',
|
|
'dmg',
|
|
'mp4',
|
|
'mid',
|
|
'mkv',
|
|
'webm',
|
|
'mov',
|
|
'avi',
|
|
'mpg',
|
|
'mp2',
|
|
'mp3',
|
|
'm4a',
|
|
'oga',
|
|
'ogg',
|
|
'ogv',
|
|
'opus',
|
|
'flac',
|
|
'wav',
|
|
'spx',
|
|
'amr',
|
|
'pdf',
|
|
'epub',
|
|
'exe',
|
|
'swf',
|
|
'rtf',
|
|
'wasm',
|
|
'woff',
|
|
'woff2',
|
|
'eot',
|
|
'ttf',
|
|
'otf',
|
|
'ico',
|
|
'flv',
|
|
'ps',
|
|
'xz',
|
|
'sqlite',
|
|
'nes',
|
|
'crx',
|
|
'xpi',
|
|
'cab',
|
|
'deb',
|
|
'ar',
|
|
'rpm',
|
|
'Z',
|
|
'lz',
|
|
'cfb',
|
|
'mxf',
|
|
'mts',
|
|
'blend',
|
|
'bpg',
|
|
'docx',
|
|
'pptx',
|
|
'xlsx',
|
|
'3gp',
|
|
'3g2',
|
|
'jp2',
|
|
'jpm',
|
|
'jpx',
|
|
'mj2',
|
|
'aif',
|
|
'qcp',
|
|
'odt',
|
|
'ods',
|
|
'odp',
|
|
'xml',
|
|
'mobi',
|
|
'heic',
|
|
'cur',
|
|
'ktx',
|
|
'ape',
|
|
'wv',
|
|
'dcm',
|
|
'ics',
|
|
'glb',
|
|
'pcap',
|
|
'dsf',
|
|
'lnk',
|
|
'alias',
|
|
'voc',
|
|
'ac3',
|
|
'm4v',
|
|
'm4p',
|
|
'm4b',
|
|
'f4v',
|
|
'f4p',
|
|
'f4b',
|
|
'f4a',
|
|
'mie',
|
|
'asf',
|
|
'ogm',
|
|
'ogx',
|
|
'mpc',
|
|
'arrow',
|
|
'shp',
|
|
'aac',
|
|
'mp1',
|
|
'it',
|
|
's3m',
|
|
'xm',
|
|
'ai',
|
|
'skp',
|
|
'avif',
|
|
'eps',
|
|
'lzh',
|
|
'pgp',
|
|
'asar',
|
|
'stl',
|
|
'chm',
|
|
'3mf',
|
|
'zst',
|
|
'jxl',
|
|
'vcf'
|
|
],
|
|
mimeTypes: [
|
|
'image/jpeg',
|
|
'image/png',
|
|
'image/gif',
|
|
'image/webp',
|
|
'image/flif',
|
|
'image/x-xcf',
|
|
'image/x-canon-cr2',
|
|
'image/x-canon-cr3',
|
|
'image/tiff',
|
|
'image/bmp',
|
|
'image/vnd.ms-photo',
|
|
'image/vnd.adobe.photoshop',
|
|
'application/x-indesign',
|
|
'application/epub+zip',
|
|
'application/x-xpinstall',
|
|
'application/vnd.oasis.opendocument.text',
|
|
'application/vnd.oasis.opendocument.spreadsheet',
|
|
'application/vnd.oasis.opendocument.presentation',
|
|
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
|
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
|
|
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
|
'application/zip',
|
|
'application/x-tar',
|
|
'application/x-rar-compressed',
|
|
'application/gzip',
|
|
'application/x-bzip2',
|
|
'application/x-7z-compressed',
|
|
'application/x-apple-diskimage',
|
|
'application/x-apache-arrow',
|
|
'video/mp4',
|
|
'audio/midi',
|
|
'video/x-matroska',
|
|
'video/webm',
|
|
'video/quicktime',
|
|
'video/vnd.avi',
|
|
'audio/vnd.wave',
|
|
'audio/qcelp',
|
|
'audio/x-ms-asf',
|
|
'video/x-ms-asf',
|
|
'application/vnd.ms-asf',
|
|
'video/mpeg',
|
|
'video/3gpp',
|
|
'audio/mpeg',
|
|
'audio/mp4', // RFC 4337
|
|
'audio/opus',
|
|
'video/ogg',
|
|
'audio/ogg',
|
|
'application/ogg',
|
|
'audio/x-flac',
|
|
'audio/ape',
|
|
'audio/wavpack',
|
|
'audio/amr',
|
|
'application/pdf',
|
|
'application/x-msdownload',
|
|
'application/x-shockwave-flash',
|
|
'application/rtf',
|
|
'application/wasm',
|
|
'font/woff',
|
|
'font/woff2',
|
|
'application/vnd.ms-fontobject',
|
|
'font/ttf',
|
|
'font/otf',
|
|
'image/x-icon',
|
|
'video/x-flv',
|
|
'application/postscript',
|
|
'application/eps',
|
|
'application/x-xz',
|
|
'application/x-sqlite3',
|
|
'application/x-nintendo-nes-rom',
|
|
'application/x-google-chrome-extension',
|
|
'application/vnd.ms-cab-compressed',
|
|
'application/x-deb',
|
|
'application/x-unix-archive',
|
|
'application/x-rpm',
|
|
'application/x-compress',
|
|
'application/x-lzip',
|
|
'application/x-cfb',
|
|
'application/x-mie',
|
|
'application/mxf',
|
|
'video/mp2t',
|
|
'application/x-blender',
|
|
'image/bpg',
|
|
'image/jp2',
|
|
'image/jpx',
|
|
'image/jpm',
|
|
'image/mj2',
|
|
'audio/aiff',
|
|
'application/xml',
|
|
'application/x-mobipocket-ebook',
|
|
'image/heif',
|
|
'image/heif-sequence',
|
|
'image/heic',
|
|
'image/heic-sequence',
|
|
'image/icns',
|
|
'image/ktx',
|
|
'application/dicom',
|
|
'audio/x-musepack',
|
|
'text/calendar',
|
|
'text/vcard',
|
|
'model/gltf-binary',
|
|
'application/vnd.tcpdump.pcap',
|
|
'audio/x-dsf', // Non-standard
|
|
'application/x.ms.shortcut', // Invented by us
|
|
'application/x.apple.alias', // Invented by us
|
|
'audio/x-voc',
|
|
'audio/vnd.dolby.dd-raw',
|
|
'audio/x-m4a',
|
|
'image/apng',
|
|
'image/x-olympus-orf',
|
|
'image/x-sony-arw',
|
|
'image/x-adobe-dng',
|
|
'image/x-nikon-nef',
|
|
'image/x-panasonic-rw2',
|
|
'image/x-fujifilm-raf',
|
|
'video/x-m4v',
|
|
'video/3gpp2',
|
|
'application/x-esri-shape',
|
|
'audio/aac',
|
|
'audio/x-it',
|
|
'audio/x-s3m',
|
|
'audio/x-xm',
|
|
'video/MP1S',
|
|
'video/MP2P',
|
|
'application/vnd.sketchup.skp',
|
|
'image/avif',
|
|
'application/x-lzh-compressed',
|
|
'application/pgp-encrypted',
|
|
'application/x-asar',
|
|
'model/stl',
|
|
'application/vnd.ms-htmlhelp',
|
|
'model/3mf',
|
|
'image/jxl',
|
|
'application/zstd'
|
|
]
|
|
};
|
|
|
|
const Token = lib$1;
|
|
const strtok3$1 = core$3;
|
|
const {
|
|
stringToBytes,
|
|
tarHeaderChecksumMatches,
|
|
uint32SyncSafeToken
|
|
} = util$4;
|
|
const supported = supported$1;
|
|
|
|
const minimumBytes = 4100; // A fair amount of file-types are detectable within this range
|
|
|
|
async function fromStream(stream) {
|
|
const tokenizer = await strtok3$1.fromStream(stream);
|
|
try {
|
|
return await fromTokenizer(tokenizer);
|
|
} finally {
|
|
await tokenizer.close();
|
|
}
|
|
}
|
|
|
|
async function fromBuffer(input) {
|
|
if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
|
|
throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
|
|
}
|
|
|
|
const buffer = input instanceof Buffer ? input : Buffer.from(input);
|
|
|
|
if (!(buffer && buffer.length > 1)) {
|
|
return;
|
|
}
|
|
|
|
const tokenizer = strtok3$1.fromBuffer(buffer);
|
|
return fromTokenizer(tokenizer);
|
|
}
|
|
|
|
function _check(buffer, headers, options) {
|
|
options = {
|
|
offset: 0,
|
|
...options
|
|
};
|
|
|
|
for (const [index, header] of headers.entries()) {
|
|
// If a bitmask is set
|
|
if (options.mask) {
|
|
// If header doesn't equal `buf` with bits masked off
|
|
if (header !== (options.mask[index] & buffer[index + options.offset])) {
|
|
return false;
|
|
}
|
|
} else if (header !== buffer[index + options.offset]) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
async function fromTokenizer(tokenizer) {
|
|
try {
|
|
return _fromTokenizer(tokenizer);
|
|
} catch (error) {
|
|
if (!(error instanceof strtok3$1.EndOfStreamError)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function _fromTokenizer(tokenizer) {
|
|
let buffer = Buffer.alloc(minimumBytes);
|
|
const bytesRead = 12;
|
|
const check = (header, options) => _check(buffer, header, options);
|
|
const checkString = (header, options) => check(stringToBytes(header), options);
|
|
|
|
// Keep reading until EOF if the file size is unknown.
|
|
if (!tokenizer.fileInfo.size) {
|
|
tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
|
|
}
|
|
|
|
await tokenizer.peekBuffer(buffer, {length: bytesRead, mayBeLess: true});
|
|
|
|
// -- 2-byte signatures --
|
|
|
|
if (check([0x42, 0x4D])) {
|
|
return {
|
|
ext: 'bmp',
|
|
mime: 'image/bmp'
|
|
};
|
|
}
|
|
|
|
if (check([0x0B, 0x77])) {
|
|
return {
|
|
ext: 'ac3',
|
|
mime: 'audio/vnd.dolby.dd-raw'
|
|
};
|
|
}
|
|
|
|
if (check([0x78, 0x01])) {
|
|
return {
|
|
ext: 'dmg',
|
|
mime: 'application/x-apple-diskimage'
|
|
};
|
|
}
|
|
|
|
if (check([0x4D, 0x5A])) {
|
|
return {
|
|
ext: 'exe',
|
|
mime: 'application/x-msdownload'
|
|
};
|
|
}
|
|
|
|
if (check([0x25, 0x21])) {
|
|
await tokenizer.peekBuffer(buffer, {length: 24, mayBeLess: true});
|
|
|
|
if (checkString('PS-Adobe-', {offset: 2}) &&
|
|
checkString(' EPSF-', {offset: 14})) {
|
|
return {
|
|
ext: 'eps',
|
|
mime: 'application/eps'
|
|
};
|
|
}
|
|
|
|
return {
|
|
ext: 'ps',
|
|
mime: 'application/postscript'
|
|
};
|
|
}
|
|
|
|
if (
|
|
check([0x1F, 0xA0]) ||
|
|
check([0x1F, 0x9D])
|
|
) {
|
|
return {
|
|
ext: 'Z',
|
|
mime: 'application/x-compress'
|
|
};
|
|
}
|
|
|
|
// -- 3-byte signatures --
|
|
|
|
if (check([0xFF, 0xD8, 0xFF])) {
|
|
return {
|
|
ext: 'jpg',
|
|
mime: 'image/jpeg'
|
|
};
|
|
}
|
|
|
|
if (check([0x49, 0x49, 0xBC])) {
|
|
return {
|
|
ext: 'jxr',
|
|
mime: 'image/vnd.ms-photo'
|
|
};
|
|
}
|
|
|
|
if (check([0x1F, 0x8B, 0x8])) {
|
|
return {
|
|
ext: 'gz',
|
|
mime: 'application/gzip'
|
|
};
|
|
}
|
|
|
|
if (check([0x42, 0x5A, 0x68])) {
|
|
return {
|
|
ext: 'bz2',
|
|
mime: 'application/x-bzip2'
|
|
};
|
|
}
|
|
|
|
if (checkString('ID3')) {
|
|
await tokenizer.ignore(6); // Skip ID3 header until the header size
|
|
const id3HeaderLen = await tokenizer.readToken(uint32SyncSafeToken);
|
|
if (tokenizer.position + id3HeaderLen > tokenizer.fileInfo.size) {
|
|
// Guess file type based on ID3 header for backward compatibility
|
|
return {
|
|
ext: 'mp3',
|
|
mime: 'audio/mpeg'
|
|
};
|
|
}
|
|
|
|
await tokenizer.ignore(id3HeaderLen);
|
|
return fromTokenizer(tokenizer); // Skip ID3 header, recursion
|
|
}
|
|
|
|
// Musepack, SV7
|
|
if (checkString('MP+')) {
|
|
return {
|
|
ext: 'mpc',
|
|
mime: 'audio/x-musepack'
|
|
};
|
|
}
|
|
|
|
if (
|
|
(buffer[0] === 0x43 || buffer[0] === 0x46) &&
|
|
check([0x57, 0x53], {offset: 1})
|
|
) {
|
|
return {
|
|
ext: 'swf',
|
|
mime: 'application/x-shockwave-flash'
|
|
};
|
|
}
|
|
|
|
// -- 4-byte signatures --
|
|
|
|
if (check([0x47, 0x49, 0x46])) {
|
|
return {
|
|
ext: 'gif',
|
|
mime: 'image/gif'
|
|
};
|
|
}
|
|
|
|
if (checkString('FLIF')) {
|
|
return {
|
|
ext: 'flif',
|
|
mime: 'image/flif'
|
|
};
|
|
}
|
|
|
|
if (checkString('8BPS')) {
|
|
return {
|
|
ext: 'psd',
|
|
mime: 'image/vnd.adobe.photoshop'
|
|
};
|
|
}
|
|
|
|
if (checkString('WEBP', {offset: 8})) {
|
|
return {
|
|
ext: 'webp',
|
|
mime: 'image/webp'
|
|
};
|
|
}
|
|
|
|
// Musepack, SV8
|
|
if (checkString('MPCK')) {
|
|
return {
|
|
ext: 'mpc',
|
|
mime: 'audio/x-musepack'
|
|
};
|
|
}
|
|
|
|
if (checkString('FORM')) {
|
|
return {
|
|
ext: 'aif',
|
|
mime: 'audio/aiff'
|
|
};
|
|
}
|
|
|
|
if (checkString('icns', {offset: 0})) {
|
|
return {
|
|
ext: 'icns',
|
|
mime: 'image/icns'
|
|
};
|
|
}
|
|
|
|
// Zip-based file formats
|
|
// Need to be before the `zip` check
|
|
if (check([0x50, 0x4B, 0x3, 0x4])) { // Local file header signature
|
|
try {
|
|
while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
|
|
await tokenizer.readBuffer(buffer, {length: 30});
|
|
|
|
// https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
|
|
const zipHeader = {
|
|
compressedSize: buffer.readUInt32LE(18),
|
|
uncompressedSize: buffer.readUInt32LE(22),
|
|
filenameLength: buffer.readUInt16LE(26),
|
|
extraFieldLength: buffer.readUInt16LE(28)
|
|
};
|
|
|
|
zipHeader.filename = await tokenizer.readToken(new Token.StringType(zipHeader.filenameLength, 'utf-8'));
|
|
await tokenizer.ignore(zipHeader.extraFieldLength);
|
|
|
|
// Assumes signed `.xpi` from addons.mozilla.org
|
|
if (zipHeader.filename === 'META-INF/mozilla.rsa') {
|
|
return {
|
|
ext: 'xpi',
|
|
mime: 'application/x-xpinstall'
|
|
};
|
|
}
|
|
|
|
if (zipHeader.filename.endsWith('.rels') || zipHeader.filename.endsWith('.xml')) {
|
|
const type = zipHeader.filename.split('/')[0];
|
|
switch (type) {
|
|
case '_rels':
|
|
break;
|
|
case 'word':
|
|
return {
|
|
ext: 'docx',
|
|
mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
|
|
};
|
|
case 'ppt':
|
|
return {
|
|
ext: 'pptx',
|
|
mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
|
|
};
|
|
case 'xl':
|
|
return {
|
|
ext: 'xlsx',
|
|
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
|
|
};
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (zipHeader.filename.startsWith('xl/')) {
|
|
return {
|
|
ext: 'xlsx',
|
|
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
|
|
};
|
|
}
|
|
|
|
if (zipHeader.filename.startsWith('3D/') && zipHeader.filename.endsWith('.model')) {
|
|
return {
|
|
ext: '3mf',
|
|
mime: 'model/3mf'
|
|
};
|
|
}
|
|
|
|
// The docx, xlsx and pptx file types extend the Office Open XML file format:
|
|
// https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
|
|
// We look for:
|
|
// - one entry named '[Content_Types].xml' or '_rels/.rels',
|
|
// - one entry indicating specific type of file.
|
|
// MS Office, OpenOffice and LibreOffice may put the parts in different order, so the check should not rely on it.
|
|
if (zipHeader.filename === 'mimetype' && zipHeader.compressedSize === zipHeader.uncompressedSize) {
|
|
const mimeType = await tokenizer.readToken(new Token.StringType(zipHeader.compressedSize, 'utf-8'));
|
|
|
|
switch (mimeType) {
|
|
case 'application/epub+zip':
|
|
return {
|
|
ext: 'epub',
|
|
mime: 'application/epub+zip'
|
|
};
|
|
case 'application/vnd.oasis.opendocument.text':
|
|
return {
|
|
ext: 'odt',
|
|
mime: 'application/vnd.oasis.opendocument.text'
|
|
};
|
|
case 'application/vnd.oasis.opendocument.spreadsheet':
|
|
return {
|
|
ext: 'ods',
|
|
mime: 'application/vnd.oasis.opendocument.spreadsheet'
|
|
};
|
|
case 'application/vnd.oasis.opendocument.presentation':
|
|
return {
|
|
ext: 'odp',
|
|
mime: 'application/vnd.oasis.opendocument.presentation'
|
|
};
|
|
default:
|
|
}
|
|
}
|
|
|
|
// Try to find next header manually when current one is corrupted
|
|
if (zipHeader.compressedSize === 0) {
|
|
let nextHeaderIndex = -1;
|
|
|
|
while (nextHeaderIndex < 0 && (tokenizer.position < tokenizer.fileInfo.size)) {
|
|
await tokenizer.peekBuffer(buffer, {mayBeLess: true});
|
|
|
|
nextHeaderIndex = buffer.indexOf('504B0304', 0, 'hex');
|
|
// Move position to the next header if found, skip the whole buffer otherwise
|
|
await tokenizer.ignore(nextHeaderIndex >= 0 ? nextHeaderIndex : buffer.length);
|
|
}
|
|
} else {
|
|
await tokenizer.ignore(zipHeader.compressedSize);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (!(error instanceof strtok3$1.EndOfStreamError)) {
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
return {
|
|
ext: 'zip',
|
|
mime: 'application/zip'
|
|
};
|
|
}
|
|
|
|
if (checkString('OggS')) {
|
|
// This is an OGG container
|
|
await tokenizer.ignore(28);
|
|
const type = Buffer.alloc(8);
|
|
await tokenizer.readBuffer(type);
|
|
|
|
// Needs to be before `ogg` check
|
|
if (_check(type, [0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64])) {
|
|
return {
|
|
ext: 'opus',
|
|
mime: 'audio/opus'
|
|
};
|
|
}
|
|
|
|
// If ' theora' in header.
|
|
if (_check(type, [0x80, 0x74, 0x68, 0x65, 0x6F, 0x72, 0x61])) {
|
|
return {
|
|
ext: 'ogv',
|
|
mime: 'video/ogg'
|
|
};
|
|
}
|
|
|
|
// If '\x01video' in header.
|
|
if (_check(type, [0x01, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x00])) {
|
|
return {
|
|
ext: 'ogm',
|
|
mime: 'video/ogg'
|
|
};
|
|
}
|
|
|
|
// If ' FLAC' in header https://xiph.org/flac/faq.html
|
|
if (_check(type, [0x7F, 0x46, 0x4C, 0x41, 0x43])) {
|
|
return {
|
|
ext: 'oga',
|
|
mime: 'audio/ogg'
|
|
};
|
|
}
|
|
|
|
// 'Speex ' in header https://en.wikipedia.org/wiki/Speex
|
|
if (_check(type, [0x53, 0x70, 0x65, 0x65, 0x78, 0x20, 0x20])) {
|
|
return {
|
|
ext: 'spx',
|
|
mime: 'audio/ogg'
|
|
};
|
|
}
|
|
|
|
// If '\x01vorbis' in header
|
|
if (_check(type, [0x01, 0x76, 0x6F, 0x72, 0x62, 0x69, 0x73])) {
|
|
return {
|
|
ext: 'ogg',
|
|
mime: 'audio/ogg'
|
|
};
|
|
}
|
|
|
|
// Default OGG container https://www.iana.org/assignments/media-types/application/ogg
|
|
return {
|
|
ext: 'ogx',
|
|
mime: 'application/ogg'
|
|
};
|
|
}
|
|
|
|
if (
|
|
check([0x50, 0x4B]) &&
|
|
(buffer[2] === 0x3 || buffer[2] === 0x5 || buffer[2] === 0x7) &&
|
|
(buffer[3] === 0x4 || buffer[3] === 0x6 || buffer[3] === 0x8)
|
|
) {
|
|
return {
|
|
ext: 'zip',
|
|
mime: 'application/zip'
|
|
};
|
|
}
|
|
|
|
//
|
|
|
|
// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
|
|
// It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.
|
|
// `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
|
|
// Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
|
|
if (
|
|
checkString('ftyp', {offset: 4}) &&
|
|
(buffer[8] & 0x60) !== 0x00 // Brand major, first character ASCII?
|
|
) {
|
|
// They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.
|
|
// For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.
|
|
const brandMajor = buffer.toString('binary', 8, 12).replace('\0', ' ').trim();
|
|
switch (brandMajor) {
|
|
case 'avif':
|
|
return {ext: 'avif', mime: 'image/avif'};
|
|
case 'mif1':
|
|
return {ext: 'heic', mime: 'image/heif'};
|
|
case 'msf1':
|
|
return {ext: 'heic', mime: 'image/heif-sequence'};
|
|
case 'heic':
|
|
case 'heix':
|
|
return {ext: 'heic', mime: 'image/heic'};
|
|
case 'hevc':
|
|
case 'hevx':
|
|
return {ext: 'heic', mime: 'image/heic-sequence'};
|
|
case 'qt':
|
|
return {ext: 'mov', mime: 'video/quicktime'};
|
|
case 'M4V':
|
|
case 'M4VH':
|
|
case 'M4VP':
|
|
return {ext: 'm4v', mime: 'video/x-m4v'};
|
|
case 'M4P':
|
|
return {ext: 'm4p', mime: 'video/mp4'};
|
|
case 'M4B':
|
|
return {ext: 'm4b', mime: 'audio/mp4'};
|
|
case 'M4A':
|
|
return {ext: 'm4a', mime: 'audio/x-m4a'};
|
|
case 'F4V':
|
|
return {ext: 'f4v', mime: 'video/mp4'};
|
|
case 'F4P':
|
|
return {ext: 'f4p', mime: 'video/mp4'};
|
|
case 'F4A':
|
|
return {ext: 'f4a', mime: 'audio/mp4'};
|
|
case 'F4B':
|
|
return {ext: 'f4b', mime: 'audio/mp4'};
|
|
case 'crx':
|
|
return {ext: 'cr3', mime: 'image/x-canon-cr3'};
|
|
default:
|
|
if (brandMajor.startsWith('3g')) {
|
|
if (brandMajor.startsWith('3g2')) {
|
|
return {ext: '3g2', mime: 'video/3gpp2'};
|
|
}
|
|
|
|
return {ext: '3gp', mime: 'video/3gpp'};
|
|
}
|
|
|
|
return {ext: 'mp4', mime: 'video/mp4'};
|
|
}
|
|
}
|
|
|
|
if (checkString('MThd')) {
|
|
return {
|
|
ext: 'mid',
|
|
mime: 'audio/midi'
|
|
};
|
|
}
|
|
|
|
if (
|
|
checkString('wOFF') &&
|
|
(
|
|
check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
|
|
checkString('OTTO', {offset: 4})
|
|
)
|
|
) {
|
|
return {
|
|
ext: 'woff',
|
|
mime: 'font/woff'
|
|
};
|
|
}
|
|
|
|
if (
|
|
checkString('wOF2') &&
|
|
(
|
|
check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
|
|
checkString('OTTO', {offset: 4})
|
|
)
|
|
) {
|
|
return {
|
|
ext: 'woff2',
|
|
mime: 'font/woff2'
|
|
};
|
|
}
|
|
|
|
if (check([0xD4, 0xC3, 0xB2, 0xA1]) || check([0xA1, 0xB2, 0xC3, 0xD4])) {
|
|
return {
|
|
ext: 'pcap',
|
|
mime: 'application/vnd.tcpdump.pcap'
|
|
};
|
|
}
|
|
|
|
// Sony DSD Stream File (DSF)
|
|
if (checkString('DSD ')) {
|
|
return {
|
|
ext: 'dsf',
|
|
mime: 'audio/x-dsf' // Non-standard
|
|
};
|
|
}
|
|
|
|
if (checkString('LZIP')) {
|
|
return {
|
|
ext: 'lz',
|
|
mime: 'application/x-lzip'
|
|
};
|
|
}
|
|
|
|
if (checkString('fLaC')) {
|
|
return {
|
|
ext: 'flac',
|
|
mime: 'audio/x-flac'
|
|
};
|
|
}
|
|
|
|
if (check([0x42, 0x50, 0x47, 0xFB])) {
|
|
return {
|
|
ext: 'bpg',
|
|
mime: 'image/bpg'
|
|
};
|
|
}
|
|
|
|
if (checkString('wvpk')) {
|
|
return {
|
|
ext: 'wv',
|
|
mime: 'audio/wavpack'
|
|
};
|
|
}
|
|
|
|
if (checkString('%PDF')) {
|
|
await tokenizer.ignore(1350);
|
|
const maxBufferSize = 10 * 1024 * 1024;
|
|
const buffer = Buffer.alloc(Math.min(maxBufferSize, tokenizer.fileInfo.size));
|
|
await tokenizer.readBuffer(buffer, {mayBeLess: true});
|
|
|
|
// Check if this is an Adobe Illustrator file
|
|
if (buffer.includes(Buffer.from('AIPrivateData'))) {
|
|
return {
|
|
ext: 'ai',
|
|
mime: 'application/postscript'
|
|
};
|
|
}
|
|
|
|
// Assume this is just a normal PDF
|
|
return {
|
|
ext: 'pdf',
|
|
mime: 'application/pdf'
|
|
};
|
|
}
|
|
|
|
if (check([0x00, 0x61, 0x73, 0x6D])) {
|
|
return {
|
|
ext: 'wasm',
|
|
mime: 'application/wasm'
|
|
};
|
|
}
|
|
|
|
// TIFF, little-endian type
|
|
if (check([0x49, 0x49, 0x2A, 0x0])) {
|
|
if (checkString('CR', {offset: 8})) {
|
|
return {
|
|
ext: 'cr2',
|
|
mime: 'image/x-canon-cr2'
|
|
};
|
|
}
|
|
|
|
if (check([0x1C, 0x00, 0xFE, 0x00], {offset: 8}) || check([0x1F, 0x00, 0x0B, 0x00], {offset: 8})) {
|
|
return {
|
|
ext: 'nef',
|
|
mime: 'image/x-nikon-nef'
|
|
};
|
|
}
|
|
|
|
if (
|
|
check([0x08, 0x00, 0x00, 0x00], {offset: 4}) &&
|
|
(check([0x2D, 0x00, 0xFE, 0x00], {offset: 8}) ||
|
|
check([0x27, 0x00, 0xFE, 0x00], {offset: 8}))
|
|
) {
|
|
return {
|
|
ext: 'dng',
|
|
mime: 'image/x-adobe-dng'
|
|
};
|
|
}
|
|
|
|
buffer = Buffer.alloc(24);
|
|
await tokenizer.peekBuffer(buffer);
|
|
if (
|
|
(check([0x10, 0xFB, 0x86, 0x01], {offset: 4}) || check([0x08, 0x00, 0x00, 0x00], {offset: 4})) &&
|
|
// This pattern differentiates ARW from other TIFF-ish file types:
|
|
check([0x00, 0xFE, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x01], {offset: 9})
|
|
) {
|
|
return {
|
|
ext: 'arw',
|
|
mime: 'image/x-sony-arw'
|
|
};
|
|
}
|
|
|
|
return {
|
|
ext: 'tif',
|
|
mime: 'image/tiff'
|
|
};
|
|
}
|
|
|
|
// TIFF, big-endian type
|
|
if (check([0x4D, 0x4D, 0x0, 0x2A])) {
|
|
return {
|
|
ext: 'tif',
|
|
mime: 'image/tiff'
|
|
};
|
|
}
|
|
|
|
if (checkString('MAC ')) {
|
|
return {
|
|
ext: 'ape',
|
|
mime: 'audio/ape'
|
|
};
|
|
}
|
|
|
|
// https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska
|
|
if (check([0x1A, 0x45, 0xDF, 0xA3])) { // Root element: EBML
|
|
async function readField() {
|
|
const msb = await tokenizer.peekNumber(Token.UINT8);
|
|
let mask = 0x80;
|
|
let ic = 0; // 0 = A, 1 = B, 2 = C, 3 = D
|
|
|
|
while ((msb & mask) === 0 && mask !== 0) {
|
|
++ic;
|
|
mask >>= 1;
|
|
}
|
|
|
|
const id = Buffer.alloc(ic + 1);
|
|
await tokenizer.readBuffer(id);
|
|
return id;
|
|
}
|
|
|
|
async function readElement() {
|
|
const id = await readField();
|
|
const lenField = await readField();
|
|
lenField[0] ^= 0x80 >> (lenField.length - 1);
|
|
const nrLen = Math.min(6, lenField.length); // JavaScript can max read 6 bytes integer
|
|
return {
|
|
id: id.readUIntBE(0, id.length),
|
|
len: lenField.readUIntBE(lenField.length - nrLen, nrLen)
|
|
};
|
|
}
|
|
|
|
async function readChildren(level, children) {
|
|
while (children > 0) {
|
|
const e = await readElement();
|
|
if (e.id === 0x4282) {
|
|
return tokenizer.readToken(new Token.StringType(e.len, 'utf-8')); // Return DocType
|
|
}
|
|
|
|
await tokenizer.ignore(e.len); // ignore payload
|
|
--children;
|
|
}
|
|
}
|
|
|
|
const re = await readElement();
|
|
const docType = await readChildren(1, re.len);
|
|
|
|
switch (docType) {
|
|
case 'webm':
|
|
return {
|
|
ext: 'webm',
|
|
mime: 'video/webm'
|
|
};
|
|
|
|
case 'matroska':
|
|
return {
|
|
ext: 'mkv',
|
|
mime: 'video/x-matroska'
|
|
};
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
// RIFF file format which might be AVI, WAV, QCP, etc
|
|
if (check([0x52, 0x49, 0x46, 0x46])) {
|
|
if (check([0x41, 0x56, 0x49], {offset: 8})) {
|
|
return {
|
|
ext: 'avi',
|
|
mime: 'video/vnd.avi'
|
|
};
|
|
}
|
|
|
|
if (check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {
|
|
return {
|
|
ext: 'wav',
|
|
mime: 'audio/vnd.wave'
|
|
};
|
|
}
|
|
|
|
// QLCM, QCP file
|
|
if (check([0x51, 0x4C, 0x43, 0x4D], {offset: 8})) {
|
|
return {
|
|
ext: 'qcp',
|
|
mime: 'audio/qcelp'
|
|
};
|
|
}
|
|
}
|
|
|
|
if (checkString('SQLi')) {
|
|
return {
|
|
ext: 'sqlite',
|
|
mime: 'application/x-sqlite3'
|
|
};
|
|
}
|
|
|
|
if (check([0x4E, 0x45, 0x53, 0x1A])) {
|
|
return {
|
|
ext: 'nes',
|
|
mime: 'application/x-nintendo-nes-rom'
|
|
};
|
|
}
|
|
|
|
if (checkString('Cr24')) {
|
|
return {
|
|
ext: 'crx',
|
|
mime: 'application/x-google-chrome-extension'
|
|
};
|
|
}
|
|
|
|
if (
|
|
checkString('MSCF') ||
|
|
checkString('ISc(')
|
|
) {
|
|
return {
|
|
ext: 'cab',
|
|
mime: 'application/vnd.ms-cab-compressed'
|
|
};
|
|
}
|
|
|
|
if (check([0xED, 0xAB, 0xEE, 0xDB])) {
|
|
return {
|
|
ext: 'rpm',
|
|
mime: 'application/x-rpm'
|
|
};
|
|
}
|
|
|
|
if (check([0xC5, 0xD0, 0xD3, 0xC6])) {
|
|
return {
|
|
ext: 'eps',
|
|
mime: 'application/eps'
|
|
};
|
|
}
|
|
|
|
if (check([0x28, 0xB5, 0x2F, 0xFD])) {
|
|
return {
|
|
ext: 'zst',
|
|
mime: 'application/zstd'
|
|
};
|
|
}
|
|
|
|
// -- 5-byte signatures --
|
|
|
|
if (check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {
|
|
return {
|
|
ext: 'otf',
|
|
mime: 'font/otf'
|
|
};
|
|
}
|
|
|
|
if (checkString('#!AMR')) {
|
|
return {
|
|
ext: 'amr',
|
|
mime: 'audio/amr'
|
|
};
|
|
}
|
|
|
|
if (checkString('{\\rtf')) {
|
|
return {
|
|
ext: 'rtf',
|
|
mime: 'application/rtf'
|
|
};
|
|
}
|
|
|
|
if (check([0x46, 0x4C, 0x56, 0x01])) {
|
|
return {
|
|
ext: 'flv',
|
|
mime: 'video/x-flv'
|
|
};
|
|
}
|
|
|
|
if (checkString('IMPM')) {
|
|
return {
|
|
ext: 'it',
|
|
mime: 'audio/x-it'
|
|
};
|
|
}
|
|
|
|
if (
|
|
checkString('-lh0-', {offset: 2}) ||
|
|
checkString('-lh1-', {offset: 2}) ||
|
|
checkString('-lh2-', {offset: 2}) ||
|
|
checkString('-lh3-', {offset: 2}) ||
|
|
checkString('-lh4-', {offset: 2}) ||
|
|
checkString('-lh5-', {offset: 2}) ||
|
|
checkString('-lh6-', {offset: 2}) ||
|
|
checkString('-lh7-', {offset: 2}) ||
|
|
checkString('-lzs-', {offset: 2}) ||
|
|
checkString('-lz4-', {offset: 2}) ||
|
|
checkString('-lz5-', {offset: 2}) ||
|
|
checkString('-lhd-', {offset: 2})
|
|
) {
|
|
return {
|
|
ext: 'lzh',
|
|
mime: 'application/x-lzh-compressed'
|
|
};
|
|
}
|
|
|
|
// MPEG program stream (PS or MPEG-PS)
|
|
if (check([0x00, 0x00, 0x01, 0xBA])) {
|
|
// MPEG-PS, MPEG-1 Part 1
|
|
if (check([0x21], {offset: 4, mask: [0xF1]})) {
|
|
return {
|
|
ext: 'mpg', // May also be .ps, .mpeg
|
|
mime: 'video/MP1S'
|
|
};
|
|
}
|
|
|
|
// MPEG-PS, MPEG-2 Part 1
|
|
if (check([0x44], {offset: 4, mask: [0xC4]})) {
|
|
return {
|
|
ext: 'mpg', // May also be .mpg, .m2p, .vob or .sub
|
|
mime: 'video/MP2P'
|
|
};
|
|
}
|
|
}
|
|
|
|
if (checkString('ITSF')) {
|
|
return {
|
|
ext: 'chm',
|
|
mime: 'application/vnd.ms-htmlhelp'
|
|
};
|
|
}
|
|
|
|
// -- 6-byte signatures --
|
|
|
|
if (check([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00])) {
|
|
return {
|
|
ext: 'xz',
|
|
mime: 'application/x-xz'
|
|
};
|
|
}
|
|
|
|
if (checkString('<?xml ')) {
|
|
return {
|
|
ext: 'xml',
|
|
mime: 'application/xml'
|
|
};
|
|
}
|
|
|
|
if (check([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])) {
|
|
return {
|
|
ext: '7z',
|
|
mime: 'application/x-7z-compressed'
|
|
};
|
|
}
|
|
|
|
if (
|
|
check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7]) &&
|
|
(buffer[6] === 0x0 || buffer[6] === 0x1)
|
|
) {
|
|
return {
|
|
ext: 'rar',
|
|
mime: 'application/x-rar-compressed'
|
|
};
|
|
}
|
|
|
|
if (checkString('solid ')) {
|
|
return {
|
|
ext: 'stl',
|
|
mime: 'model/stl'
|
|
};
|
|
}
|
|
|
|
// -- 7-byte signatures --
|
|
|
|
if (checkString('BLENDER')) {
|
|
return {
|
|
ext: 'blend',
|
|
mime: 'application/x-blender'
|
|
};
|
|
}
|
|
|
|
if (checkString('!<arch>')) {
|
|
await tokenizer.ignore(8);
|
|
const str = await tokenizer.readToken(new Token.StringType(13, 'ascii'));
|
|
if (str === 'debian-binary') {
|
|
return {
|
|
ext: 'deb',
|
|
mime: 'application/x-deb'
|
|
};
|
|
}
|
|
|
|
return {
|
|
ext: 'ar',
|
|
mime: 'application/x-unix-archive'
|
|
};
|
|
}
|
|
|
|
// -- 8-byte signatures --
|
|
|
|
if (check([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
|
// APNG format (https://wiki.mozilla.org/APNG_Specification)
|
|
// 1. Find the first IDAT (image data) chunk (49 44 41 54)
|
|
// 2. Check if there is an "acTL" chunk before the IDAT one (61 63 54 4C)
|
|
|
|
// Offset calculated as follows:
|
|
// - 8 bytes: PNG signature
|
|
// - 4 (length) + 4 (chunk type) + 13 (chunk data) + 4 (CRC): IHDR chunk
|
|
|
|
await tokenizer.ignore(8); // ignore PNG signature
|
|
|
|
async function readChunkHeader() {
|
|
return {
|
|
length: await tokenizer.readToken(Token.INT32_BE),
|
|
type: await tokenizer.readToken(new Token.StringType(4, 'binary'))
|
|
};
|
|
}
|
|
|
|
do {
|
|
const chunk = await readChunkHeader();
|
|
if (chunk.length < 0) {
|
|
return; // Invalid chunk length
|
|
}
|
|
|
|
switch (chunk.type) {
|
|
case 'IDAT':
|
|
return {
|
|
ext: 'png',
|
|
mime: 'image/png'
|
|
};
|
|
case 'acTL':
|
|
return {
|
|
ext: 'apng',
|
|
mime: 'image/apng'
|
|
};
|
|
default:
|
|
await tokenizer.ignore(chunk.length + 4); // Ignore chunk-data + CRC
|
|
}
|
|
} while (tokenizer.position + 8 < tokenizer.fileInfo.size);
|
|
|
|
return {
|
|
ext: 'png',
|
|
mime: 'image/png'
|
|
};
|
|
}
|
|
|
|
if (check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {
|
|
return {
|
|
ext: 'arrow',
|
|
mime: 'application/x-apache-arrow'
|
|
};
|
|
}
|
|
|
|
if (check([0x67, 0x6C, 0x54, 0x46, 0x02, 0x00, 0x00, 0x00])) {
|
|
return {
|
|
ext: 'glb',
|
|
mime: 'model/gltf-binary'
|
|
};
|
|
}
|
|
|
|
// `mov` format variants
|
|
if (
|
|
check([0x66, 0x72, 0x65, 0x65], {offset: 4}) || // `free`
|
|
check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) || // `mdat` MJPEG
|
|
check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) || // `moov`
|
|
check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`
|
|
) {
|
|
return {
|
|
ext: 'mov',
|
|
mime: 'video/quicktime'
|
|
};
|
|
}
|
|
|
|
// -- 9-byte signatures --
|
|
|
|
if (check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {
|
|
return {
|
|
ext: 'orf',
|
|
mime: 'image/x-olympus-orf'
|
|
};
|
|
}
|
|
|
|
if (checkString('gimp xcf ')) {
|
|
return {
|
|
ext: 'xcf',
|
|
mime: 'image/x-xcf'
|
|
};
|
|
}
|
|
|
|
// -- 12-byte signatures --
|
|
|
|
if (check([0x49, 0x49, 0x55, 0x00, 0x18, 0x00, 0x00, 0x00, 0x88, 0xE7, 0x74, 0xD8])) {
|
|
return {
|
|
ext: 'rw2',
|
|
mime: 'image/x-panasonic-rw2'
|
|
};
|
|
}
|
|
|
|
// ASF_Header_Object first 80 bytes
|
|
if (check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {
|
|
async function readHeader() {
|
|
const guid = Buffer.alloc(16);
|
|
await tokenizer.readBuffer(guid);
|
|
return {
|
|
id: guid,
|
|
size: Number(await tokenizer.readToken(Token.UINT64_LE))
|
|
};
|
|
}
|
|
|
|
await tokenizer.ignore(30);
|
|
// Search for header should be in first 1KB of file.
|
|
while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
|
|
const header = await readHeader();
|
|
let payload = header.size - 24;
|
|
if (_check(header.id, [0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65])) {
|
|
// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
|
|
const typeId = Buffer.alloc(16);
|
|
payload -= await tokenizer.readBuffer(typeId);
|
|
|
|
if (_check(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
|
// Found audio:
|
|
return {
|
|
ext: 'asf',
|
|
mime: 'audio/x-ms-asf'
|
|
};
|
|
}
|
|
|
|
if (_check(typeId, [0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
|
// Found video:
|
|
return {
|
|
ext: 'asf',
|
|
mime: 'video/x-ms-asf'
|
|
};
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
await tokenizer.ignore(payload);
|
|
}
|
|
|
|
// Default to ASF generic extension
|
|
return {
|
|
ext: 'asf',
|
|
mime: 'application/vnd.ms-asf'
|
|
};
|
|
}
|
|
|
|
if (check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
|
return {
|
|
ext: 'ktx',
|
|
mime: 'image/ktx'
|
|
};
|
|
}
|
|
|
|
if ((check([0x7E, 0x10, 0x04]) || check([0x7E, 0x18, 0x04])) && check([0x30, 0x4D, 0x49, 0x45], {offset: 4})) {
|
|
return {
|
|
ext: 'mie',
|
|
mime: 'application/x-mie'
|
|
};
|
|
}
|
|
|
|
if (check([0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], {offset: 2})) {
|
|
return {
|
|
ext: 'shp',
|
|
mime: 'application/x-esri-shape'
|
|
};
|
|
}
|
|
|
|
if (check([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A])) {
|
|
// JPEG-2000 family
|
|
|
|
await tokenizer.ignore(20);
|
|
const type = await tokenizer.readToken(new Token.StringType(4, 'ascii'));
|
|
switch (type) {
|
|
case 'jp2 ':
|
|
return {
|
|
ext: 'jp2',
|
|
mime: 'image/jp2'
|
|
};
|
|
case 'jpx ':
|
|
return {
|
|
ext: 'jpx',
|
|
mime: 'image/jpx'
|
|
};
|
|
case 'jpm ':
|
|
return {
|
|
ext: 'jpm',
|
|
mime: 'image/jpm'
|
|
};
|
|
case 'mjp2':
|
|
return {
|
|
ext: 'mj2',
|
|
mime: 'image/mj2'
|
|
};
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (
|
|
check([0xFF, 0x0A]) ||
|
|
check([0x00, 0x00, 0x00, 0x0C, 0x4A, 0x58, 0x4C, 0x20, 0x0D, 0x0A, 0x87, 0x0A])
|
|
) {
|
|
return {
|
|
ext: 'jxl',
|
|
mime: 'image/jxl'
|
|
};
|
|
}
|
|
|
|
// -- Unsafe signatures --
|
|
|
|
if (
|
|
check([0x0, 0x0, 0x1, 0xBA]) ||
|
|
check([0x0, 0x0, 0x1, 0xB3])
|
|
) {
|
|
return {
|
|
ext: 'mpg',
|
|
mime: 'video/mpeg'
|
|
};
|
|
}
|
|
|
|
if (check([0x00, 0x01, 0x00, 0x00, 0x00])) {
|
|
return {
|
|
ext: 'ttf',
|
|
mime: 'font/ttf'
|
|
};
|
|
}
|
|
|
|
if (check([0x00, 0x00, 0x01, 0x00])) {
|
|
return {
|
|
ext: 'ico',
|
|
mime: 'image/x-icon'
|
|
};
|
|
}
|
|
|
|
if (check([0x00, 0x00, 0x02, 0x00])) {
|
|
return {
|
|
ext: 'cur',
|
|
mime: 'image/x-icon'
|
|
};
|
|
}
|
|
|
|
if (check([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1])) {
|
|
// Detected Microsoft Compound File Binary File (MS-CFB) Format.
|
|
return {
|
|
ext: 'cfb',
|
|
mime: 'application/x-cfb'
|
|
};
|
|
}
|
|
|
|
// Increase sample size from 12 to 256.
|
|
await tokenizer.peekBuffer(buffer, {length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true});
|
|
|
|
// -- 15-byte signatures --
|
|
|
|
if (checkString('BEGIN:')) {
|
|
if (checkString('VCARD', {offset: 6})) {
|
|
return {
|
|
ext: 'vcf',
|
|
mime: 'text/vcard'
|
|
};
|
|
}
|
|
|
|
if (checkString('VCALENDAR', {offset: 6})) {
|
|
return {
|
|
ext: 'ics',
|
|
mime: 'text/calendar'
|
|
};
|
|
}
|
|
}
|
|
|
|
// `raf` is here just to keep all the raw image detectors together.
|
|
if (checkString('FUJIFILMCCD-RAW')) {
|
|
return {
|
|
ext: 'raf',
|
|
mime: 'image/x-fujifilm-raf'
|
|
};
|
|
}
|
|
|
|
if (checkString('Extended Module:')) {
|
|
return {
|
|
ext: 'xm',
|
|
mime: 'audio/x-xm'
|
|
};
|
|
}
|
|
|
|
if (checkString('Creative Voice File')) {
|
|
return {
|
|
ext: 'voc',
|
|
mime: 'audio/x-voc'
|
|
};
|
|
}
|
|
|
|
if (check([0x04, 0x00, 0x00, 0x00]) && buffer.length >= 16) { // Rough & quick check Pickle/ASAR
|
|
const jsonSize = buffer.readUInt32LE(12);
|
|
if (jsonSize > 12 && buffer.length >= jsonSize + 16) {
|
|
try {
|
|
const header = buffer.slice(16, jsonSize + 16).toString();
|
|
const json = JSON.parse(header);
|
|
// Check if Pickle is ASAR
|
|
if (json.files) { // Final check, assuring Pickle/ASAR format
|
|
return {
|
|
ext: 'asar',
|
|
mime: 'application/x-asar'
|
|
};
|
|
}
|
|
} catch (_) {
|
|
}
|
|
}
|
|
}
|
|
|
|
if (check([0x06, 0x0E, 0x2B, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0D, 0x01, 0x02, 0x01, 0x01, 0x02])) {
|
|
return {
|
|
ext: 'mxf',
|
|
mime: 'application/mxf'
|
|
};
|
|
}
|
|
|
|
if (checkString('SCRM', {offset: 44})) {
|
|
return {
|
|
ext: 's3m',
|
|
mime: 'audio/x-s3m'
|
|
};
|
|
}
|
|
|
|
if (check([0x47], {offset: 4}) && (check([0x47], {offset: 192}) || check([0x47], {offset: 196}))) {
|
|
return {
|
|
ext: 'mts',
|
|
mime: 'video/mp2t'
|
|
};
|
|
}
|
|
|
|
if (check([0x42, 0x4F, 0x4F, 0x4B, 0x4D, 0x4F, 0x42, 0x49], {offset: 60})) {
|
|
return {
|
|
ext: 'mobi',
|
|
mime: 'application/x-mobipocket-ebook'
|
|
};
|
|
}
|
|
|
|
if (check([0x44, 0x49, 0x43, 0x4D], {offset: 128})) {
|
|
return {
|
|
ext: 'dcm',
|
|
mime: 'application/dicom'
|
|
};
|
|
}
|
|
|
|
if (check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {
|
|
return {
|
|
ext: 'lnk',
|
|
mime: 'application/x.ms.shortcut' // Invented by us
|
|
};
|
|
}
|
|
|
|
if (check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {
|
|
return {
|
|
ext: 'alias',
|
|
mime: 'application/x.apple.alias' // Invented by us
|
|
};
|
|
}
|
|
|
|
if (
|
|
check([0x4C, 0x50], {offset: 34}) &&
|
|
(
|
|
check([0x00, 0x00, 0x01], {offset: 8}) ||
|
|
check([0x01, 0x00, 0x02], {offset: 8}) ||
|
|
check([0x02, 0x00, 0x02], {offset: 8})
|
|
)
|
|
) {
|
|
return {
|
|
ext: 'eot',
|
|
mime: 'application/vnd.ms-fontobject'
|
|
};
|
|
}
|
|
|
|
if (check([0x06, 0x06, 0xED, 0xF5, 0xD8, 0x1D, 0x46, 0xE5, 0xBD, 0x31, 0xEF, 0xE7, 0xFE, 0x74, 0xB7, 0x1D])) {
|
|
return {
|
|
ext: 'indd',
|
|
mime: 'application/x-indesign'
|
|
};
|
|
}
|
|
|
|
// Increase sample size from 256 to 512
|
|
await tokenizer.peekBuffer(buffer, {length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true});
|
|
|
|
// Requires a buffer size of 512 bytes
|
|
if (tarHeaderChecksumMatches(buffer)) {
|
|
return {
|
|
ext: 'tar',
|
|
mime: 'application/x-tar'
|
|
};
|
|
}
|
|
|
|
if (check([0xFF, 0xFE, 0xFF, 0x0E, 0x53, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x55, 0x00, 0x70, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00])) {
|
|
return {
|
|
ext: 'skp',
|
|
mime: 'application/vnd.sketchup.skp'
|
|
};
|
|
}
|
|
|
|
if (checkString('-----BEGIN PGP MESSAGE-----')) {
|
|
return {
|
|
ext: 'pgp',
|
|
mime: 'application/pgp-encrypted'
|
|
};
|
|
}
|
|
|
|
// Check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE)
|
|
if (buffer.length >= 2 && check([0xFF, 0xE0], {offset: 0, mask: [0xFF, 0xE0]})) {
|
|
if (check([0x10], {offset: 1, mask: [0x16]})) {
|
|
// Check for (ADTS) MPEG-2
|
|
if (check([0x08], {offset: 1, mask: [0x08]})) {
|
|
return {
|
|
ext: 'aac',
|
|
mime: 'audio/aac'
|
|
};
|
|
}
|
|
|
|
// Must be (ADTS) MPEG-4
|
|
return {
|
|
ext: 'aac',
|
|
mime: 'audio/aac'
|
|
};
|
|
}
|
|
|
|
// MPEG 1 or 2 Layer 3 header
|
|
// Check for MPEG layer 3
|
|
if (check([0x02], {offset: 1, mask: [0x06]})) {
|
|
return {
|
|
ext: 'mp3',
|
|
mime: 'audio/mpeg'
|
|
};
|
|
}
|
|
|
|
// Check for MPEG layer 2
|
|
if (check([0x04], {offset: 1, mask: [0x06]})) {
|
|
return {
|
|
ext: 'mp2',
|
|
mime: 'audio/mpeg'
|
|
};
|
|
}
|
|
|
|
// Check for MPEG layer 1
|
|
if (check([0x06], {offset: 1, mask: [0x06]})) {
|
|
return {
|
|
ext: 'mp1',
|
|
mime: 'audio/mpeg'
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
const stream = readableStream => new Promise((resolve, reject) => {
|
|
// Using `eval` to work around issues when bundling with Webpack
|
|
const stream = eval('require')('stream'); // eslint-disable-line no-eval
|
|
|
|
readableStream.on('error', reject);
|
|
readableStream.once('readable', async () => {
|
|
// Set up output stream
|
|
const pass = new stream.PassThrough();
|
|
let outputStream;
|
|
if (stream.pipeline) {
|
|
outputStream = stream.pipeline(readableStream, pass, () => {
|
|
});
|
|
} else {
|
|
outputStream = readableStream.pipe(pass);
|
|
}
|
|
|
|
// Read the input stream and detect the filetype
|
|
const chunk = readableStream.read(minimumBytes) || readableStream.read() || Buffer.alloc(0);
|
|
try {
|
|
const fileType = await fromBuffer(chunk);
|
|
pass.fileType = fileType;
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
|
|
resolve(outputStream);
|
|
});
|
|
});
|
|
|
|
const fileType$1 = {
|
|
fromStream,
|
|
fromTokenizer,
|
|
fromBuffer,
|
|
stream
|
|
};
|
|
|
|
Object.defineProperty(fileType$1, 'extensions', {
|
|
get() {
|
|
return new Set(supported.extensions);
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(fileType$1, 'mimeTypes', {
|
|
get() {
|
|
return new Set(supported.mimeTypes);
|
|
}
|
|
});
|
|
|
|
var core$2 = fileType$1;
|
|
|
|
const strtok3 = lib$3;
|
|
const core$1 = core$2;
|
|
|
|
async function fromFile(path) {
|
|
const tokenizer = await strtok3.fromFile(path);
|
|
try {
|
|
return await core$1.fromTokenizer(tokenizer);
|
|
} finally {
|
|
await tokenizer.close();
|
|
}
|
|
}
|
|
|
|
const fileType = {
|
|
fromFile
|
|
};
|
|
|
|
Object.assign(fileType, core$1);
|
|
|
|
Object.defineProperty(fileType, 'extensions', {
|
|
get() {
|
|
return core$1.extensions;
|
|
}
|
|
});
|
|
|
|
Object.defineProperty(fileType, 'mimeTypes', {
|
|
get() {
|
|
return core$1.mimeTypes;
|
|
}
|
|
});
|
|
|
|
var fileType_1 = fileType;
|
|
|
|
var isSvg$2 = {exports: {}};
|
|
|
|
var validator$2 = {};
|
|
|
|
var util$3 = {};
|
|
|
|
(function (exports) {
|
|
|
|
const nameStartChar = ':A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
|
|
const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
|
|
const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';
|
|
const regexName = new RegExp('^' + nameRegexp + '$');
|
|
|
|
const getAllMatches = function(string, regex) {
|
|
const matches = [];
|
|
let match = regex.exec(string);
|
|
while (match) {
|
|
const allmatches = [];
|
|
allmatches.startIndex = regex.lastIndex - match[0].length;
|
|
const len = match.length;
|
|
for (let index = 0; index < len; index++) {
|
|
allmatches.push(match[index]);
|
|
}
|
|
matches.push(allmatches);
|
|
match = regex.exec(string);
|
|
}
|
|
return matches;
|
|
};
|
|
|
|
const isName = function(string) {
|
|
const match = regexName.exec(string);
|
|
return !(match === null || typeof match === 'undefined');
|
|
};
|
|
|
|
exports.isExist = function(v) {
|
|
return typeof v !== 'undefined';
|
|
};
|
|
|
|
exports.isEmptyObject = function(obj) {
|
|
return Object.keys(obj).length === 0;
|
|
};
|
|
|
|
/**
|
|
* Copy all the properties of a into b.
|
|
* @param {*} target
|
|
* @param {*} a
|
|
*/
|
|
exports.merge = function(target, a, arrayMode) {
|
|
if (a) {
|
|
const keys = Object.keys(a); // will return an array of own properties
|
|
const len = keys.length; //don't make it inline
|
|
for (let i = 0; i < len; i++) {
|
|
if (arrayMode === 'strict') {
|
|
target[keys[i]] = [ a[keys[i]] ];
|
|
} else {
|
|
target[keys[i]] = a[keys[i]];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
/* exports.merge =function (b,a){
|
|
return Object.assign(b,a);
|
|
} */
|
|
|
|
exports.getValue = function(v) {
|
|
if (exports.isExist(v)) {
|
|
return v;
|
|
} else {
|
|
return '';
|
|
}
|
|
};
|
|
|
|
// const fakeCall = function(a) {return a;};
|
|
// const fakeCallNoReturn = function() {};
|
|
|
|
exports.isName = isName;
|
|
exports.getAllMatches = getAllMatches;
|
|
exports.nameRegexp = nameRegexp;
|
|
} (util$3));
|
|
|
|
const util$2 = util$3;
|
|
|
|
const defaultOptions$2 = {
|
|
allowBooleanAttributes: false, //A tag can have attributes without any value
|
|
unpairedTags: []
|
|
};
|
|
|
|
//const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
|
|
validator$2.validate = function (xmlData, options) {
|
|
options = Object.assign({}, defaultOptions$2, options);
|
|
|
|
//xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
|
|
//xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag
|
|
//xmlData = xmlData.replace(/(<!DOCTYPE[\s\w\"\.\/\-\:]+(\[.*\])*\s*>)/g,"");//Remove DOCTYPE
|
|
const tags = [];
|
|
let tagFound = false;
|
|
|
|
//indicates that the root tag has been closed (aka. depth 0 has been reached)
|
|
let reachedRoot = false;
|
|
|
|
if (xmlData[0] === '\ufeff') {
|
|
// check for byte order mark (BOM)
|
|
xmlData = xmlData.substr(1);
|
|
}
|
|
|
|
for (let i = 0; i < xmlData.length; i++) {
|
|
|
|
if (xmlData[i] === '<' && xmlData[i+1] === '?') {
|
|
i+=2;
|
|
i = readPI(xmlData,i);
|
|
if (i.err) return i;
|
|
}else if (xmlData[i] === '<') {
|
|
//starting of tag
|
|
//read until you reach to '>' avoiding any '>' in attribute value
|
|
let tagStartPos = i;
|
|
i++;
|
|
|
|
if (xmlData[i] === '!') {
|
|
i = readCommentAndCDATA(xmlData, i);
|
|
continue;
|
|
} else {
|
|
let closingTag = false;
|
|
if (xmlData[i] === '/') {
|
|
//closing tag
|
|
closingTag = true;
|
|
i++;
|
|
}
|
|
//read tagname
|
|
let tagName = '';
|
|
for (; i < xmlData.length &&
|
|
xmlData[i] !== '>' &&
|
|
xmlData[i] !== ' ' &&
|
|
xmlData[i] !== '\t' &&
|
|
xmlData[i] !== '\n' &&
|
|
xmlData[i] !== '\r'; i++
|
|
) {
|
|
tagName += xmlData[i];
|
|
}
|
|
tagName = tagName.trim();
|
|
//console.log(tagName);
|
|
|
|
if (tagName[tagName.length - 1] === '/') {
|
|
//self closing tag without attributes
|
|
tagName = tagName.substring(0, tagName.length - 1);
|
|
//continue;
|
|
i--;
|
|
}
|
|
if (!validateTagName(tagName)) {
|
|
let msg;
|
|
if (tagName.trim().length === 0) {
|
|
msg = "Invalid space after '<'.";
|
|
} else {
|
|
msg = "Tag '"+tagName+"' is an invalid name.";
|
|
}
|
|
return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));
|
|
}
|
|
|
|
const result = readAttributeStr(xmlData, i);
|
|
if (result === false) {
|
|
return getErrorObject('InvalidAttr', "Attributes for '"+tagName+"' have open quote.", getLineNumberForPosition(xmlData, i));
|
|
}
|
|
let attrStr = result.value;
|
|
i = result.index;
|
|
|
|
if (attrStr[attrStr.length - 1] === '/') {
|
|
//self closing tag
|
|
const attrStrStart = i - attrStr.length;
|
|
attrStr = attrStr.substring(0, attrStr.length - 1);
|
|
const isValid = validateAttributeString(attrStr, options);
|
|
if (isValid === true) {
|
|
tagFound = true;
|
|
//continue; //text may presents after self closing tag
|
|
} else {
|
|
//the result from the nested function returns the position of the error within the attribute
|
|
//in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
|
|
//this gives us the absolute index in the entire xml, which we can use to find the line at last
|
|
return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
|
|
}
|
|
} else if (closingTag) {
|
|
if (!result.tagClosed) {
|
|
return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
|
|
} else if (attrStr.trim().length > 0) {
|
|
return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
|
|
} else if (tags.length === 0) {
|
|
return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
|
|
} else {
|
|
const otg = tags.pop();
|
|
if (tagName !== otg.tagName) {
|
|
let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
|
|
return getErrorObject('InvalidTag',
|
|
"Expected closing tag '"+otg.tagName+"' (opened in line "+openPos.line+", col "+openPos.col+") instead of closing tag '"+tagName+"'.",
|
|
getLineNumberForPosition(xmlData, tagStartPos));
|
|
}
|
|
|
|
//when there are no more tags, we reached the root level.
|
|
if (tags.length == 0) {
|
|
reachedRoot = true;
|
|
}
|
|
}
|
|
} else {
|
|
const isValid = validateAttributeString(attrStr, options);
|
|
if (isValid !== true) {
|
|
//the result from the nested function returns the position of the error within the attribute
|
|
//in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
|
|
//this gives us the absolute index in the entire xml, which we can use to find the line at last
|
|
return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
|
|
}
|
|
|
|
//if the root level has been reached before ...
|
|
if (reachedRoot === true) {
|
|
return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
|
|
} else if(options.unpairedTags.indexOf(tagName) !== -1); else {
|
|
tags.push({tagName, tagStartPos});
|
|
}
|
|
tagFound = true;
|
|
}
|
|
|
|
//skip tag text value
|
|
//It may include comments and CDATA value
|
|
for (i++; i < xmlData.length; i++) {
|
|
if (xmlData[i] === '<') {
|
|
if (xmlData[i + 1] === '!') {
|
|
//comment or CADATA
|
|
i++;
|
|
i = readCommentAndCDATA(xmlData, i);
|
|
continue;
|
|
} else if (xmlData[i+1] === '?') {
|
|
i = readPI(xmlData, ++i);
|
|
if (i.err) return i;
|
|
} else {
|
|
break;
|
|
}
|
|
} else if (xmlData[i] === '&') {
|
|
const afterAmp = validateAmpersand(xmlData, i);
|
|
if (afterAmp == -1)
|
|
return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
|
|
i = afterAmp;
|
|
}else {
|
|
if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
|
|
return getErrorObject('InvalidXml', "Extra text at the end", getLineNumberForPosition(xmlData, i));
|
|
}
|
|
}
|
|
} //end of reading tag text value
|
|
if (xmlData[i] === '<') {
|
|
i--;
|
|
}
|
|
}
|
|
} else {
|
|
if ( isWhiteSpace(xmlData[i])) {
|
|
continue;
|
|
}
|
|
return getErrorObject('InvalidChar', "char '"+xmlData[i]+"' is not expected.", getLineNumberForPosition(xmlData, i));
|
|
}
|
|
}
|
|
|
|
if (!tagFound) {
|
|
return getErrorObject('InvalidXml', 'Start tag expected.', 1);
|
|
}else if (tags.length == 1) {
|
|
return getErrorObject('InvalidTag', "Unclosed tag '"+tags[0].tagName+"'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
|
|
}else if (tags.length > 0) {
|
|
return getErrorObject('InvalidXml', "Invalid '"+
|
|
JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\r?\n/g, '')+
|
|
"' found.", {line: 1, col: 1});
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
function isWhiteSpace(char){
|
|
return char === ' ' || char === '\t' || char === '\n' || char === '\r';
|
|
}
|
|
/**
|
|
* Read Processing insstructions and skip
|
|
* @param {*} xmlData
|
|
* @param {*} i
|
|
*/
|
|
function readPI(xmlData, i) {
|
|
const start = i;
|
|
for (; i < xmlData.length; i++) {
|
|
if (xmlData[i] == '?' || xmlData[i] == ' ') {
|
|
//tagname
|
|
const tagname = xmlData.substr(start, i - start);
|
|
if (i > 5 && tagname === 'xml') {
|
|
return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));
|
|
} else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {
|
|
//check if valid attribut string
|
|
i++;
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
function readCommentAndCDATA(xmlData, i) {
|
|
if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {
|
|
//comment
|
|
for (i += 3; i < xmlData.length; i++) {
|
|
if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {
|
|
i += 2;
|
|
break;
|
|
}
|
|
}
|
|
} else if (
|
|
xmlData.length > i + 8 &&
|
|
xmlData[i + 1] === 'D' &&
|
|
xmlData[i + 2] === 'O' &&
|
|
xmlData[i + 3] === 'C' &&
|
|
xmlData[i + 4] === 'T' &&
|
|
xmlData[i + 5] === 'Y' &&
|
|
xmlData[i + 6] === 'P' &&
|
|
xmlData[i + 7] === 'E'
|
|
) {
|
|
let angleBracketsCount = 1;
|
|
for (i += 8; i < xmlData.length; i++) {
|
|
if (xmlData[i] === '<') {
|
|
angleBracketsCount++;
|
|
} else if (xmlData[i] === '>') {
|
|
angleBracketsCount--;
|
|
if (angleBracketsCount === 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if (
|
|
xmlData.length > i + 9 &&
|
|
xmlData[i + 1] === '[' &&
|
|
xmlData[i + 2] === 'C' &&
|
|
xmlData[i + 3] === 'D' &&
|
|
xmlData[i + 4] === 'A' &&
|
|
xmlData[i + 5] === 'T' &&
|
|
xmlData[i + 6] === 'A' &&
|
|
xmlData[i + 7] === '['
|
|
) {
|
|
for (i += 8; i < xmlData.length; i++) {
|
|
if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {
|
|
i += 2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
const doubleQuote = '"';
|
|
const singleQuote = "'";
|
|
|
|
/**
|
|
* Keep reading xmlData until '<' is found outside the attribute value.
|
|
* @param {string} xmlData
|
|
* @param {number} i
|
|
*/
|
|
function readAttributeStr(xmlData, i) {
|
|
let attrStr = '';
|
|
let startChar = '';
|
|
let tagClosed = false;
|
|
for (; i < xmlData.length; i++) {
|
|
if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
|
|
if (startChar === '') {
|
|
startChar = xmlData[i];
|
|
} else if (startChar !== xmlData[i]) ; else {
|
|
startChar = '';
|
|
}
|
|
} else if (xmlData[i] === '>') {
|
|
if (startChar === '') {
|
|
tagClosed = true;
|
|
break;
|
|
}
|
|
}
|
|
attrStr += xmlData[i];
|
|
}
|
|
if (startChar !== '') {
|
|
return false;
|
|
}
|
|
|
|
return {
|
|
value: attrStr,
|
|
index: i,
|
|
tagClosed: tagClosed
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Select all the attributes whether valid or invalid.
|
|
*/
|
|
const validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g');
|
|
|
|
//attr, ="sd", a="amit's", a="sd"b="saf", ab cd=""
|
|
|
|
function validateAttributeString(attrStr, options) {
|
|
//console.log("start:"+attrStr+":end");
|
|
|
|
//if(attrStr.trim().length === 0) return true; //empty string
|
|
|
|
const matches = util$2.getAllMatches(attrStr, validAttrStrRegxp);
|
|
const attrNames = {};
|
|
|
|
for (let i = 0; i < matches.length; i++) {
|
|
if (matches[i][1].length === 0) {
|
|
//nospace before attribute name: a="sd"b="saf"
|
|
return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(matches[i]))
|
|
} else if (matches[i][3] !== undefined && matches[i][4] === undefined) {
|
|
return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' is without value.", getPositionFromMatch(matches[i]));
|
|
} else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
|
|
//independent attribute: ab
|
|
return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(matches[i]));
|
|
}
|
|
/* else if(matches[i][6] === undefined){//attribute without value: ab=
|
|
return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}};
|
|
} */
|
|
const attrName = matches[i][2];
|
|
if (!validateAttrName(attrName)) {
|
|
return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(matches[i]));
|
|
}
|
|
if (!attrNames.hasOwnProperty(attrName)) {
|
|
//check for duplicate attribute.
|
|
attrNames[attrName] = 1;
|
|
} else {
|
|
return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(matches[i]));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function validateNumberAmpersand(xmlData, i) {
|
|
let re = /\d/;
|
|
if (xmlData[i] === 'x') {
|
|
i++;
|
|
re = /[\da-fA-F]/;
|
|
}
|
|
for (; i < xmlData.length; i++) {
|
|
if (xmlData[i] === ';')
|
|
return i;
|
|
if (!xmlData[i].match(re))
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
function validateAmpersand(xmlData, i) {
|
|
// https://www.w3.org/TR/xml/#dt-charref
|
|
i++;
|
|
if (xmlData[i] === ';')
|
|
return -1;
|
|
if (xmlData[i] === '#') {
|
|
i++;
|
|
return validateNumberAmpersand(xmlData, i);
|
|
}
|
|
let count = 0;
|
|
for (; i < xmlData.length; i++, count++) {
|
|
if (xmlData[i].match(/\w/) && count < 20)
|
|
continue;
|
|
if (xmlData[i] === ';')
|
|
break;
|
|
return -1;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
function getErrorObject(code, message, lineNumber) {
|
|
return {
|
|
err: {
|
|
code: code,
|
|
msg: message,
|
|
line: lineNumber.line || lineNumber,
|
|
col: lineNumber.col,
|
|
},
|
|
};
|
|
}
|
|
|
|
function validateAttrName(attrName) {
|
|
return util$2.isName(attrName);
|
|
}
|
|
|
|
// const startsWithXML = /^xml/i;
|
|
|
|
function validateTagName(tagname) {
|
|
return util$2.isName(tagname) /* && !tagname.match(startsWithXML) */;
|
|
}
|
|
|
|
//this function returns the line number for the character at the given index
|
|
function getLineNumberForPosition(xmlData, index) {
|
|
const lines = xmlData.substring(0, index).split(/\r?\n/);
|
|
return {
|
|
line: lines.length,
|
|
|
|
// column number is last line's length + 1, because column numbering starts at 1:
|
|
col: lines[lines.length - 1].length + 1
|
|
};
|
|
}
|
|
|
|
//this function returns the position of the first character of match within attrStr
|
|
function getPositionFromMatch(match) {
|
|
return match.startIndex + match[1].length;
|
|
}
|
|
|
|
var OptionsBuilder = {};
|
|
|
|
const defaultOptions$1 = {
|
|
preserveOrder: false,
|
|
attributeNamePrefix: '@_',
|
|
attributesGroupName: false,
|
|
textNodeName: '#text',
|
|
ignoreAttributes: true,
|
|
removeNSPrefix: false, // remove NS from tag name or attribute name if true
|
|
allowBooleanAttributes: false, //a tag can have attributes without any value
|
|
//ignoreRootElement : false,
|
|
parseTagValue: true,
|
|
parseAttributeValue: false,
|
|
trimValues: true, //Trim string values of tag and attributes
|
|
cdataPropName: false,
|
|
numberParseOptions: {
|
|
hex: true,
|
|
leadingZeros: true,
|
|
eNotation: true
|
|
},
|
|
tagValueProcessor: function(tagName, val) {
|
|
return val;
|
|
},
|
|
attributeValueProcessor: function(attrName, val) {
|
|
return val;
|
|
},
|
|
stopNodes: [], //nested tags will not be parsed even for errors
|
|
alwaysCreateTextNode: false,
|
|
isArray: () => false,
|
|
commentPropName: false,
|
|
unpairedTags: [],
|
|
processEntities: true,
|
|
htmlEntities: false,
|
|
ignoreDeclaration: false,
|
|
ignorePiTags: false,
|
|
transformTagName: false,
|
|
transformAttributeName: false,
|
|
updateTag: function(tagName, jPath, attrs){
|
|
return tagName
|
|
},
|
|
// skipEmptyListItem: false
|
|
};
|
|
|
|
const buildOptions$1 = function(options) {
|
|
return Object.assign({}, defaultOptions$1, options);
|
|
};
|
|
|
|
OptionsBuilder.buildOptions = buildOptions$1;
|
|
OptionsBuilder.defaultOptions = defaultOptions$1;
|
|
|
|
class XmlNode{
|
|
constructor(tagname) {
|
|
this.tagname = tagname;
|
|
this.child = []; //nested tags, text, cdata, comments in order
|
|
this[":@"] = {}; //attributes map
|
|
}
|
|
add(key,val){
|
|
// this.child.push( {name : key, val: val, isCdata: isCdata });
|
|
if(key === "__proto__") key = "#__proto__";
|
|
this.child.push( {[key]: val });
|
|
}
|
|
addChild(node) {
|
|
if(node.tagname === "__proto__") node.tagname = "#__proto__";
|
|
if(node[":@"] && Object.keys(node[":@"]).length > 0){
|
|
this.child.push( { [node.tagname]: node.child, [":@"]: node[":@"] });
|
|
}else {
|
|
this.child.push( { [node.tagname]: node.child });
|
|
}
|
|
};
|
|
}
|
|
|
|
var xmlNode$1 = XmlNode;
|
|
|
|
const util$1 = util$3;
|
|
|
|
//TODO: handle comments
|
|
function readDocType$1(xmlData, i){
|
|
|
|
const entities = {};
|
|
if( xmlData[i + 3] === 'O' &&
|
|
xmlData[i + 4] === 'C' &&
|
|
xmlData[i + 5] === 'T' &&
|
|
xmlData[i + 6] === 'Y' &&
|
|
xmlData[i + 7] === 'P' &&
|
|
xmlData[i + 8] === 'E')
|
|
{
|
|
i = i+9;
|
|
let angleBracketsCount = 1;
|
|
let hasBody = false, comment = false;
|
|
let exp = "";
|
|
for(;i<xmlData.length;i++){
|
|
if (xmlData[i] === '<' && !comment) { //Determine the tag type
|
|
if( hasBody && isEntity(xmlData, i)){
|
|
i += 7;
|
|
let entityName, val;
|
|
[entityName, val,i] = readEntityExp(xmlData,i+1);
|
|
if(val.indexOf("&") === -1) //Parameter entities are not supported
|
|
entities[ validateEntityName(entityName) ] = {
|
|
regx : RegExp( `&${entityName};`,"g"),
|
|
val: val
|
|
};
|
|
}
|
|
else if( hasBody && isElement(xmlData, i)) i += 8;//Not supported
|
|
else if( hasBody && isAttlist(xmlData, i)) i += 8;//Not supported
|
|
else if( hasBody && isNotation(xmlData, i)) i += 9;//Not supported
|
|
else if( isComment) comment = true;
|
|
else throw new Error("Invalid DOCTYPE");
|
|
|
|
angleBracketsCount++;
|
|
exp = "";
|
|
} else if (xmlData[i] === '>') { //Read tag content
|
|
if(comment){
|
|
if( xmlData[i - 1] === "-" && xmlData[i - 2] === "-"){
|
|
comment = false;
|
|
angleBracketsCount--;
|
|
}
|
|
}else {
|
|
angleBracketsCount--;
|
|
}
|
|
if (angleBracketsCount === 0) {
|
|
break;
|
|
}
|
|
}else if( xmlData[i] === '['){
|
|
hasBody = true;
|
|
}else {
|
|
exp += xmlData[i];
|
|
}
|
|
}
|
|
if(angleBracketsCount !== 0){
|
|
throw new Error(`Unclosed DOCTYPE`);
|
|
}
|
|
}else {
|
|
throw new Error(`Invalid Tag instead of DOCTYPE`);
|
|
}
|
|
return {entities, i};
|
|
}
|
|
|
|
function readEntityExp(xmlData,i){
|
|
//External entities are not supported
|
|
// <!ENTITY ext SYSTEM "http://normal-website.com" >
|
|
|
|
//Parameter entities are not supported
|
|
// <!ENTITY entityname "&anotherElement;">
|
|
|
|
//Internal entities are supported
|
|
// <!ENTITY entityname "replacement text">
|
|
|
|
//read EntityName
|
|
let entityName = "";
|
|
for (; i < xmlData.length && (xmlData[i] !== "'" && xmlData[i] !== '"' ); i++) {
|
|
// if(xmlData[i] === " ") continue;
|
|
// else
|
|
entityName += xmlData[i];
|
|
}
|
|
entityName = entityName.trim();
|
|
if(entityName.indexOf(" ") !== -1) throw new Error("External entites are not supported");
|
|
|
|
//read Entity Value
|
|
const startChar = xmlData[i++];
|
|
let val = "";
|
|
for (; i < xmlData.length && xmlData[i] !== startChar ; i++) {
|
|
val += xmlData[i];
|
|
}
|
|
return [entityName, val, i];
|
|
}
|
|
|
|
function isComment(xmlData, i){
|
|
if(xmlData[i+1] === '!' &&
|
|
xmlData[i+2] === '-' &&
|
|
xmlData[i+3] === '-') return true
|
|
return false
|
|
}
|
|
function isEntity(xmlData, i){
|
|
if(xmlData[i+1] === '!' &&
|
|
xmlData[i+2] === 'E' &&
|
|
xmlData[i+3] === 'N' &&
|
|
xmlData[i+4] === 'T' &&
|
|
xmlData[i+5] === 'I' &&
|
|
xmlData[i+6] === 'T' &&
|
|
xmlData[i+7] === 'Y') return true
|
|
return false
|
|
}
|
|
function isElement(xmlData, i){
|
|
if(xmlData[i+1] === '!' &&
|
|
xmlData[i+2] === 'E' &&
|
|
xmlData[i+3] === 'L' &&
|
|
xmlData[i+4] === 'E' &&
|
|
xmlData[i+5] === 'M' &&
|
|
xmlData[i+6] === 'E' &&
|
|
xmlData[i+7] === 'N' &&
|
|
xmlData[i+8] === 'T') return true
|
|
return false
|
|
}
|
|
|
|
function isAttlist(xmlData, i){
|
|
if(xmlData[i+1] === '!' &&
|
|
xmlData[i+2] === 'A' &&
|
|
xmlData[i+3] === 'T' &&
|
|
xmlData[i+4] === 'T' &&
|
|
xmlData[i+5] === 'L' &&
|
|
xmlData[i+6] === 'I' &&
|
|
xmlData[i+7] === 'S' &&
|
|
xmlData[i+8] === 'T') return true
|
|
return false
|
|
}
|
|
function isNotation(xmlData, i){
|
|
if(xmlData[i+1] === '!' &&
|
|
xmlData[i+2] === 'N' &&
|
|
xmlData[i+3] === 'O' &&
|
|
xmlData[i+4] === 'T' &&
|
|
xmlData[i+5] === 'A' &&
|
|
xmlData[i+6] === 'T' &&
|
|
xmlData[i+7] === 'I' &&
|
|
xmlData[i+8] === 'O' &&
|
|
xmlData[i+9] === 'N') return true
|
|
return false
|
|
}
|
|
|
|
function validateEntityName(name){
|
|
if (util$1.isName(name))
|
|
return name;
|
|
else
|
|
throw new Error(`Invalid entity name ${name}`);
|
|
}
|
|
|
|
var DocTypeReader = readDocType$1;
|
|
|
|
const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
|
|
const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
|
|
// const octRegex = /^0x[a-z0-9]+/;
|
|
// const binRegex = /0x[a-z0-9]+/;
|
|
|
|
|
|
const consider = {
|
|
hex : true,
|
|
// oct: false,
|
|
leadingZeros: true,
|
|
decimalPoint: "\.",
|
|
eNotation: true,
|
|
//skipLike: /regex/
|
|
};
|
|
|
|
function toNumber$1(str, options = {}){
|
|
options = Object.assign({}, consider, options );
|
|
if(!str || typeof str !== "string" ) return str;
|
|
|
|
let trimmedStr = str.trim();
|
|
|
|
if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
|
|
else if(str==="0") return 0;
|
|
else if (options.hex && hexRegex.test(trimmedStr)) {
|
|
return parse_int(trimmedStr, 16);
|
|
// }else if (options.oct && octRegex.test(str)) {
|
|
// return Number.parseInt(val, 8);
|
|
}else if (trimmedStr.search(/[eE]/)!== -1) { //eNotation
|
|
const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
|
|
// +00.123 => [ , '+', '00', '.123', ..
|
|
if(notation){
|
|
// console.log(notation)
|
|
if(options.leadingZeros){ //accept with leading zeros
|
|
trimmedStr = (notation[1] || "") + notation[3];
|
|
}else {
|
|
if(notation[2] === "0" && notation[3][0]=== ".");else {
|
|
return str;
|
|
}
|
|
}
|
|
return options.eNotation ? Number(trimmedStr) : str;
|
|
}else {
|
|
return str;
|
|
}
|
|
// }else if (options.parseBin && binRegex.test(str)) {
|
|
// return Number.parseInt(val, 2);
|
|
}else {
|
|
//separate negative sign, leading zeros, and rest number
|
|
const match = numRegex.exec(trimmedStr);
|
|
// +00.123 => [ , '+', '00', '.123', ..
|
|
if(match){
|
|
const sign = match[1];
|
|
const leadingZeros = match[2];
|
|
let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
|
|
//trim ending zeros for floating number
|
|
|
|
if(!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123
|
|
else if(!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123
|
|
else if(options.leadingZeros && leadingZeros===str) return 0; //00
|
|
|
|
else {//no leading zeros or leading zeros are allowed
|
|
const num = Number(trimmedStr);
|
|
const numStr = "" + num;
|
|
|
|
if(numStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
|
|
if(options.eNotation) return num;
|
|
else return str;
|
|
}else if(trimmedStr.indexOf(".") !== -1){ //floating number
|
|
if(numStr === "0" && (numTrimmedByZeros === "") ) return num; //0.0
|
|
else if(numStr === numTrimmedByZeros) return num; //0.456. 0.79000
|
|
else if( sign && numStr === "-"+numTrimmedByZeros) return num;
|
|
else return str;
|
|
}
|
|
|
|
if(leadingZeros){
|
|
return (numTrimmedByZeros === numStr) || (sign+numTrimmedByZeros === numStr) ? num : str
|
|
}else {
|
|
return (trimmedStr === numStr) || (trimmedStr === sign+numStr) ? num : str
|
|
}
|
|
}
|
|
}else { //non-numeric string
|
|
return str;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {string} numStr without leading zeros
|
|
* @returns
|
|
*/
|
|
function trimZeros(numStr){
|
|
if(numStr && numStr.indexOf(".") !== -1){//float
|
|
numStr = numStr.replace(/0+$/, ""); //remove ending zeros
|
|
if(numStr === ".") numStr = "0";
|
|
else if(numStr[0] === ".") numStr = "0"+numStr;
|
|
else if(numStr[numStr.length-1] === ".") numStr = numStr.substr(0,numStr.length-1);
|
|
return numStr;
|
|
}
|
|
return numStr;
|
|
}
|
|
|
|
function parse_int(numStr, base){
|
|
//polyfill
|
|
if(parseInt) return parseInt(numStr, base);
|
|
else if(Number.parseInt) return Number.parseInt(numStr, base);
|
|
else if(window && window.parseInt) return window.parseInt(numStr, base);
|
|
else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")
|
|
}
|
|
|
|
var strnum = toNumber$1;
|
|
|
|
function getIgnoreAttributesFn$2(ignoreAttributes) {
|
|
if (typeof ignoreAttributes === 'function') {
|
|
return ignoreAttributes
|
|
}
|
|
if (Array.isArray(ignoreAttributes)) {
|
|
return (attrName) => {
|
|
for (const pattern of ignoreAttributes) {
|
|
if (typeof pattern === 'string' && attrName === pattern) {
|
|
return true
|
|
}
|
|
if (pattern instanceof RegExp && pattern.test(attrName)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return () => false
|
|
}
|
|
|
|
var ignoreAttributes = getIgnoreAttributesFn$2;
|
|
|
|
///@ts-check
|
|
|
|
const util = util$3;
|
|
const xmlNode = xmlNode$1;
|
|
const readDocType = DocTypeReader;
|
|
const toNumber = strnum;
|
|
const getIgnoreAttributesFn$1 = ignoreAttributes;
|
|
|
|
// const regx =
|
|
// '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
|
|
// .replace(/NAME/g, util.nameRegexp);
|
|
|
|
//const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
|
|
//const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
|
|
|
|
class OrderedObjParser$1{
|
|
constructor(options){
|
|
this.options = options;
|
|
this.currentNode = null;
|
|
this.tagsNodeStack = [];
|
|
this.docTypeEntities = {};
|
|
this.lastEntities = {
|
|
"apos" : { regex: /&(apos|#39|#x27);/g, val : "'"},
|
|
"gt" : { regex: /&(gt|#62|#x3E);/g, val : ">"},
|
|
"lt" : { regex: /&(lt|#60|#x3C);/g, val : "<"},
|
|
"quot" : { regex: /&(quot|#34|#x22);/g, val : "\""},
|
|
};
|
|
this.ampEntity = { regex: /&(amp|#38|#x26);/g, val : "&"};
|
|
this.htmlEntities = {
|
|
"space": { regex: /&(nbsp|#160);/g, val: " " },
|
|
// "lt" : { regex: /&(lt|#60);/g, val: "<" },
|
|
// "gt" : { regex: /&(gt|#62);/g, val: ">" },
|
|
// "amp" : { regex: /&(amp|#38);/g, val: "&" },
|
|
// "quot" : { regex: /&(quot|#34);/g, val: "\"" },
|
|
// "apos" : { regex: /&(apos|#39);/g, val: "'" },
|
|
"cent" : { regex: /&(cent|#162);/g, val: "¢" },
|
|
"pound" : { regex: /&(pound|#163);/g, val: "£" },
|
|
"yen" : { regex: /&(yen|#165);/g, val: "¥" },
|
|
"euro" : { regex: /&(euro|#8364);/g, val: "€" },
|
|
"copyright" : { regex: /&(copy|#169);/g, val: "©" },
|
|
"reg" : { regex: /&(reg|#174);/g, val: "®" },
|
|
"inr" : { regex: /&(inr|#8377);/g, val: "₹" },
|
|
"num_dec": { regex: /&#([0-9]{1,7});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 10)) },
|
|
"num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val : (_, str) => String.fromCharCode(Number.parseInt(str, 16)) },
|
|
};
|
|
this.addExternalEntities = addExternalEntities;
|
|
this.parseXml = parseXml;
|
|
this.parseTextData = parseTextData;
|
|
this.resolveNameSpace = resolveNameSpace;
|
|
this.buildAttributesMap = buildAttributesMap;
|
|
this.isItStopNode = isItStopNode;
|
|
this.replaceEntitiesValue = replaceEntitiesValue$1;
|
|
this.readStopNodeData = readStopNodeData;
|
|
this.saveTextToParentTag = saveTextToParentTag;
|
|
this.addChild = addChild;
|
|
this.ignoreAttributesFn = getIgnoreAttributesFn$1(this.options.ignoreAttributes);
|
|
}
|
|
|
|
}
|
|
|
|
function addExternalEntities(externalEntities){
|
|
const entKeys = Object.keys(externalEntities);
|
|
for (let i = 0; i < entKeys.length; i++) {
|
|
const ent = entKeys[i];
|
|
this.lastEntities[ent] = {
|
|
regex: new RegExp("&"+ent+";","g"),
|
|
val : externalEntities[ent]
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} val
|
|
* @param {string} tagName
|
|
* @param {string} jPath
|
|
* @param {boolean} dontTrim
|
|
* @param {boolean} hasAttributes
|
|
* @param {boolean} isLeafNode
|
|
* @param {boolean} escapeEntities
|
|
*/
|
|
function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
|
|
if (val !== undefined) {
|
|
if (this.options.trimValues && !dontTrim) {
|
|
val = val.trim();
|
|
}
|
|
if(val.length > 0){
|
|
if(!escapeEntities) val = this.replaceEntitiesValue(val);
|
|
|
|
const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
|
|
if(newval === null || newval === undefined){
|
|
//don't parse
|
|
return val;
|
|
}else if(typeof newval !== typeof val || newval !== val){
|
|
//overwrite
|
|
return newval;
|
|
}else if(this.options.trimValues){
|
|
return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
|
|
}else {
|
|
const trimmedVal = val.trim();
|
|
if(trimmedVal === val){
|
|
return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
|
|
}else {
|
|
return val;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveNameSpace(tagname) {
|
|
if (this.options.removeNSPrefix) {
|
|
const tags = tagname.split(':');
|
|
const prefix = tagname.charAt(0) === '/' ? '/' : '';
|
|
if (tags[0] === 'xmlns') {
|
|
return '';
|
|
}
|
|
if (tags.length === 2) {
|
|
tagname = prefix + tags[1];
|
|
}
|
|
}
|
|
return tagname;
|
|
}
|
|
|
|
//TODO: change regex to capture NS
|
|
//const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm");
|
|
const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])([\\s\\S]*?)\\3)?', 'gm');
|
|
|
|
function buildAttributesMap(attrStr, jPath, tagName) {
|
|
if (this.options.ignoreAttributes !== true && typeof attrStr === 'string') {
|
|
// attrStr = attrStr.replace(/\r?\n/g, ' ');
|
|
//attrStr = attrStr || attrStr.trim();
|
|
|
|
const matches = util.getAllMatches(attrStr, attrsRegx);
|
|
const len = matches.length; //don't make it inline
|
|
const attrs = {};
|
|
for (let i = 0; i < len; i++) {
|
|
const attrName = this.resolveNameSpace(matches[i][1]);
|
|
if (this.ignoreAttributesFn(attrName, jPath)) {
|
|
continue
|
|
}
|
|
let oldVal = matches[i][4];
|
|
let aName = this.options.attributeNamePrefix + attrName;
|
|
if (attrName.length) {
|
|
if (this.options.transformAttributeName) {
|
|
aName = this.options.transformAttributeName(aName);
|
|
}
|
|
if(aName === "__proto__") aName = "#__proto__";
|
|
if (oldVal !== undefined) {
|
|
if (this.options.trimValues) {
|
|
oldVal = oldVal.trim();
|
|
}
|
|
oldVal = this.replaceEntitiesValue(oldVal);
|
|
const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
|
|
if(newVal === null || newVal === undefined){
|
|
//don't parse
|
|
attrs[aName] = oldVal;
|
|
}else if(typeof newVal !== typeof oldVal || newVal !== oldVal){
|
|
//overwrite
|
|
attrs[aName] = newVal;
|
|
}else {
|
|
//parse
|
|
attrs[aName] = parseValue(
|
|
oldVal,
|
|
this.options.parseAttributeValue,
|
|
this.options.numberParseOptions
|
|
);
|
|
}
|
|
} else if (this.options.allowBooleanAttributes) {
|
|
attrs[aName] = true;
|
|
}
|
|
}
|
|
}
|
|
if (!Object.keys(attrs).length) {
|
|
return;
|
|
}
|
|
if (this.options.attributesGroupName) {
|
|
const attrCollection = {};
|
|
attrCollection[this.options.attributesGroupName] = attrs;
|
|
return attrCollection;
|
|
}
|
|
return attrs
|
|
}
|
|
}
|
|
|
|
const parseXml = function(xmlData) {
|
|
xmlData = xmlData.replace(/\r\n?/g, "\n"); //TODO: remove this line
|
|
const xmlObj = new xmlNode('!xml');
|
|
let currentNode = xmlObj;
|
|
let textData = "";
|
|
let jPath = "";
|
|
for(let i=0; i< xmlData.length; i++){//for each char in XML data
|
|
const ch = xmlData[i];
|
|
if(ch === '<'){
|
|
// const nextIndex = i+1;
|
|
// const _2ndChar = xmlData[nextIndex];
|
|
if( xmlData[i+1] === '/') {//Closing Tag
|
|
const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
|
|
let tagName = xmlData.substring(i+2,closeIndex).trim();
|
|
|
|
if(this.options.removeNSPrefix){
|
|
const colonIndex = tagName.indexOf(":");
|
|
if(colonIndex !== -1){
|
|
tagName = tagName.substr(colonIndex+1);
|
|
}
|
|
}
|
|
|
|
if(this.options.transformTagName) {
|
|
tagName = this.options.transformTagName(tagName);
|
|
}
|
|
|
|
if(currentNode){
|
|
textData = this.saveTextToParentTag(textData, currentNode, jPath);
|
|
}
|
|
|
|
//check if last tag of nested tag was unpaired tag
|
|
const lastTagName = jPath.substring(jPath.lastIndexOf(".")+1);
|
|
if(tagName && this.options.unpairedTags.indexOf(tagName) !== -1 ){
|
|
throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
|
|
}
|
|
let propIndex = 0;
|
|
if(lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1 ){
|
|
propIndex = jPath.lastIndexOf('.', jPath.lastIndexOf('.')-1);
|
|
this.tagsNodeStack.pop();
|
|
}else {
|
|
propIndex = jPath.lastIndexOf(".");
|
|
}
|
|
jPath = jPath.substring(0, propIndex);
|
|
|
|
currentNode = this.tagsNodeStack.pop();//avoid recursion, set the parent tag scope
|
|
textData = "";
|
|
i = closeIndex;
|
|
} else if( xmlData[i+1] === '?') {
|
|
|
|
let tagData = readTagExp(xmlData,i, false, "?>");
|
|
if(!tagData) throw new Error("Pi Tag is not closed.");
|
|
|
|
textData = this.saveTextToParentTag(textData, currentNode, jPath);
|
|
if( (this.options.ignoreDeclaration && tagData.tagName === "?xml") || this.options.ignorePiTags);else {
|
|
|
|
const childNode = new xmlNode(tagData.tagName);
|
|
childNode.add(this.options.textNodeName, "");
|
|
|
|
if(tagData.tagName !== tagData.tagExp && tagData.attrExpPresent){
|
|
childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
|
|
}
|
|
this.addChild(currentNode, childNode, jPath);
|
|
|
|
}
|
|
|
|
|
|
i = tagData.closeIndex + 1;
|
|
} else if(xmlData.substr(i + 1, 3) === '!--') {
|
|
const endIndex = findClosingIndex(xmlData, "-->", i+4, "Comment is not closed.");
|
|
if(this.options.commentPropName){
|
|
const comment = xmlData.substring(i + 4, endIndex - 2);
|
|
|
|
textData = this.saveTextToParentTag(textData, currentNode, jPath);
|
|
|
|
currentNode.add(this.options.commentPropName, [ { [this.options.textNodeName] : comment } ]);
|
|
}
|
|
i = endIndex;
|
|
} else if( xmlData.substr(i + 1, 2) === '!D') {
|
|
const result = readDocType(xmlData, i);
|
|
this.docTypeEntities = result.entities;
|
|
i = result.i;
|
|
}else if(xmlData.substr(i + 1, 2) === '![') {
|
|
const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
|
|
const tagExp = xmlData.substring(i + 9,closeIndex);
|
|
|
|
textData = this.saveTextToParentTag(textData, currentNode, jPath);
|
|
|
|
let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
|
|
if(val == undefined) val = "";
|
|
|
|
//cdata should be set even if it is 0 length string
|
|
if(this.options.cdataPropName){
|
|
currentNode.add(this.options.cdataPropName, [ { [this.options.textNodeName] : tagExp } ]);
|
|
}else {
|
|
currentNode.add(this.options.textNodeName, val);
|
|
}
|
|
|
|
i = closeIndex + 2;
|
|
}else {//Opening tag
|
|
let result = readTagExp(xmlData,i, this.options.removeNSPrefix);
|
|
let tagName= result.tagName;
|
|
const rawTagName = result.rawTagName;
|
|
let tagExp = result.tagExp;
|
|
let attrExpPresent = result.attrExpPresent;
|
|
let closeIndex = result.closeIndex;
|
|
|
|
if (this.options.transformTagName) {
|
|
tagName = this.options.transformTagName(tagName);
|
|
}
|
|
|
|
//save text as child node
|
|
if (currentNode && textData) {
|
|
if(currentNode.tagname !== '!xml'){
|
|
//when nested tag is found
|
|
textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
|
|
}
|
|
}
|
|
|
|
//check if last tag was unpaired tag
|
|
const lastTag = currentNode;
|
|
if(lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1 ){
|
|
currentNode = this.tagsNodeStack.pop();
|
|
jPath = jPath.substring(0, jPath.lastIndexOf("."));
|
|
}
|
|
if(tagName !== xmlObj.tagname){
|
|
jPath += jPath ? "." + tagName : tagName;
|
|
}
|
|
if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
|
|
let tagContent = "";
|
|
//self-closing tag
|
|
if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
|
|
if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
|
|
tagName = tagName.substr(0, tagName.length - 1);
|
|
jPath = jPath.substr(0, jPath.length - 1);
|
|
tagExp = tagName;
|
|
}else {
|
|
tagExp = tagExp.substr(0, tagExp.length - 1);
|
|
}
|
|
i = result.closeIndex;
|
|
}
|
|
//unpaired tag
|
|
else if(this.options.unpairedTags.indexOf(tagName) !== -1){
|
|
|
|
i = result.closeIndex;
|
|
}
|
|
//normal tag
|
|
else {
|
|
//read until closing tag is found
|
|
const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
|
|
if(!result) throw new Error(`Unexpected end of ${rawTagName}`);
|
|
i = result.i;
|
|
tagContent = result.tagContent;
|
|
}
|
|
|
|
const childNode = new xmlNode(tagName);
|
|
if(tagName !== tagExp && attrExpPresent){
|
|
childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
|
|
}
|
|
if(tagContent) {
|
|
tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
|
|
}
|
|
|
|
jPath = jPath.substr(0, jPath.lastIndexOf("."));
|
|
childNode.add(this.options.textNodeName, tagContent);
|
|
|
|
this.addChild(currentNode, childNode, jPath);
|
|
}else {
|
|
//selfClosing tag
|
|
if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){
|
|
if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
|
|
tagName = tagName.substr(0, tagName.length - 1);
|
|
jPath = jPath.substr(0, jPath.length - 1);
|
|
tagExp = tagName;
|
|
}else {
|
|
tagExp = tagExp.substr(0, tagExp.length - 1);
|
|
}
|
|
|
|
if(this.options.transformTagName) {
|
|
tagName = this.options.transformTagName(tagName);
|
|
}
|
|
|
|
const childNode = new xmlNode(tagName);
|
|
if(tagName !== tagExp && attrExpPresent){
|
|
childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
|
|
}
|
|
this.addChild(currentNode, childNode, jPath);
|
|
jPath = jPath.substr(0, jPath.lastIndexOf("."));
|
|
}
|
|
//opening tag
|
|
else {
|
|
const childNode = new xmlNode( tagName);
|
|
this.tagsNodeStack.push(currentNode);
|
|
|
|
if(tagName !== tagExp && attrExpPresent){
|
|
childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
|
|
}
|
|
this.addChild(currentNode, childNode, jPath);
|
|
currentNode = childNode;
|
|
}
|
|
textData = "";
|
|
i = closeIndex;
|
|
}
|
|
}
|
|
}else {
|
|
textData += xmlData[i];
|
|
}
|
|
}
|
|
return xmlObj.child;
|
|
};
|
|
|
|
function addChild(currentNode, childNode, jPath){
|
|
const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
|
|
if(result === false);else if(typeof result === "string"){
|
|
childNode.tagname = result;
|
|
currentNode.addChild(childNode);
|
|
}else {
|
|
currentNode.addChild(childNode);
|
|
}
|
|
}
|
|
|
|
const replaceEntitiesValue$1 = function(val){
|
|
|
|
if(this.options.processEntities){
|
|
for(let entityName in this.docTypeEntities){
|
|
const entity = this.docTypeEntities[entityName];
|
|
val = val.replace( entity.regx, entity.val);
|
|
}
|
|
for(let entityName in this.lastEntities){
|
|
const entity = this.lastEntities[entityName];
|
|
val = val.replace( entity.regex, entity.val);
|
|
}
|
|
if(this.options.htmlEntities){
|
|
for(let entityName in this.htmlEntities){
|
|
const entity = this.htmlEntities[entityName];
|
|
val = val.replace( entity.regex, entity.val);
|
|
}
|
|
}
|
|
val = val.replace( this.ampEntity.regex, this.ampEntity.val);
|
|
}
|
|
return val;
|
|
};
|
|
function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
|
|
if (textData) { //store previously collected data as textNode
|
|
if(isLeafNode === undefined) isLeafNode = currentNode.child.length === 0;
|
|
|
|
textData = this.parseTextData(textData,
|
|
currentNode.tagname,
|
|
jPath,
|
|
false,
|
|
currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false,
|
|
isLeafNode);
|
|
|
|
if (textData !== undefined && textData !== "")
|
|
currentNode.add(this.options.textNodeName, textData);
|
|
textData = "";
|
|
}
|
|
return textData;
|
|
}
|
|
|
|
//TODO: use jPath to simplify the logic
|
|
/**
|
|
*
|
|
* @param {string[]} stopNodes
|
|
* @param {string} jPath
|
|
* @param {string} currentTagName
|
|
*/
|
|
function isItStopNode(stopNodes, jPath, currentTagName){
|
|
const allNodesExp = "*." + currentTagName;
|
|
for (const stopNodePath in stopNodes) {
|
|
const stopNodeExp = stopNodes[stopNodePath];
|
|
if( allNodesExp === stopNodeExp || jPath === stopNodeExp ) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the tag Expression and where it is ending handling single-double quotes situation
|
|
* @param {string} xmlData
|
|
* @param {number} i starting index
|
|
* @returns
|
|
*/
|
|
function tagExpWithClosingIndex(xmlData, i, closingChar = ">"){
|
|
let attrBoundary;
|
|
let tagExp = "";
|
|
for (let index = i; index < xmlData.length; index++) {
|
|
let ch = xmlData[index];
|
|
if (attrBoundary) {
|
|
if (ch === attrBoundary) attrBoundary = "";//reset
|
|
} else if (ch === '"' || ch === "'") {
|
|
attrBoundary = ch;
|
|
} else if (ch === closingChar[0]) {
|
|
if(closingChar[1]){
|
|
if(xmlData[index + 1] === closingChar[1]){
|
|
return {
|
|
data: tagExp,
|
|
index: index
|
|
}
|
|
}
|
|
}else {
|
|
return {
|
|
data: tagExp,
|
|
index: index
|
|
}
|
|
}
|
|
} else if (ch === '\t') {
|
|
ch = " ";
|
|
}
|
|
tagExp += ch;
|
|
}
|
|
}
|
|
|
|
function findClosingIndex(xmlData, str, i, errMsg){
|
|
const closingIndex = xmlData.indexOf(str, i);
|
|
if(closingIndex === -1){
|
|
throw new Error(errMsg)
|
|
}else {
|
|
return closingIndex + str.length - 1;
|
|
}
|
|
}
|
|
|
|
function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){
|
|
const result = tagExpWithClosingIndex(xmlData, i+1, closingChar);
|
|
if(!result) return;
|
|
let tagExp = result.data;
|
|
const closeIndex = result.index;
|
|
const separatorIndex = tagExp.search(/\s/);
|
|
let tagName = tagExp;
|
|
let attrExpPresent = true;
|
|
if(separatorIndex !== -1){//separate tag name and attributes expression
|
|
tagName = tagExp.substring(0, separatorIndex);
|
|
tagExp = tagExp.substring(separatorIndex + 1).trimStart();
|
|
}
|
|
|
|
const rawTagName = tagName;
|
|
if(removeNSPrefix){
|
|
const colonIndex = tagName.indexOf(":");
|
|
if(colonIndex !== -1){
|
|
tagName = tagName.substr(colonIndex+1);
|
|
attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
|
|
}
|
|
}
|
|
|
|
return {
|
|
tagName: tagName,
|
|
tagExp: tagExp,
|
|
closeIndex: closeIndex,
|
|
attrExpPresent: attrExpPresent,
|
|
rawTagName: rawTagName,
|
|
}
|
|
}
|
|
/**
|
|
* find paired tag for a stop node
|
|
* @param {string} xmlData
|
|
* @param {string} tagName
|
|
* @param {number} i
|
|
*/
|
|
function readStopNodeData(xmlData, tagName, i){
|
|
const startIndex = i;
|
|
// Starting at 1 since we already have an open tag
|
|
let openTagCount = 1;
|
|
|
|
for (; i < xmlData.length; i++) {
|
|
if( xmlData[i] === "<"){
|
|
if (xmlData[i+1] === "/") {//close tag
|
|
const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
|
|
let closeTagName = xmlData.substring(i+2,closeIndex).trim();
|
|
if(closeTagName === tagName){
|
|
openTagCount--;
|
|
if (openTagCount === 0) {
|
|
return {
|
|
tagContent: xmlData.substring(startIndex, i),
|
|
i : closeIndex
|
|
}
|
|
}
|
|
}
|
|
i=closeIndex;
|
|
} else if(xmlData[i+1] === '?') {
|
|
const closeIndex = findClosingIndex(xmlData, "?>", i+1, "StopNode is not closed.");
|
|
i=closeIndex;
|
|
} else if(xmlData.substr(i + 1, 3) === '!--') {
|
|
const closeIndex = findClosingIndex(xmlData, "-->", i+3, "StopNode is not closed.");
|
|
i=closeIndex;
|
|
} else if(xmlData.substr(i + 1, 2) === '![') {
|
|
const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
|
|
i=closeIndex;
|
|
} else {
|
|
const tagData = readTagExp(xmlData, i, '>');
|
|
|
|
if (tagData) {
|
|
const openTagName = tagData && tagData.tagName;
|
|
if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length-1] !== "/") {
|
|
openTagCount++;
|
|
}
|
|
i=tagData.closeIndex;
|
|
}
|
|
}
|
|
}
|
|
}//end for loop
|
|
}
|
|
|
|
function parseValue(val, shouldParse, options) {
|
|
if (shouldParse && typeof val === 'string') {
|
|
//console.log(options)
|
|
const newval = val.trim();
|
|
if(newval === 'true' ) return true;
|
|
else if(newval === 'false' ) return false;
|
|
else return toNumber(val, options);
|
|
} else {
|
|
if (util.isExist(val)) {
|
|
return val;
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
var OrderedObjParser_1 = OrderedObjParser$1;
|
|
|
|
var node2json = {};
|
|
|
|
/**
|
|
*
|
|
* @param {array} node
|
|
* @param {any} options
|
|
* @returns
|
|
*/
|
|
function prettify$1(node, options){
|
|
return compress( node, options);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {array} arr
|
|
* @param {object} options
|
|
* @param {string} jPath
|
|
* @returns object
|
|
*/
|
|
function compress(arr, options, jPath){
|
|
let text;
|
|
const compressedObj = {};
|
|
for (let i = 0; i < arr.length; i++) {
|
|
const tagObj = arr[i];
|
|
const property = propName$1(tagObj);
|
|
let newJpath = "";
|
|
if(jPath === undefined) newJpath = property;
|
|
else newJpath = jPath + "." + property;
|
|
|
|
if(property === options.textNodeName){
|
|
if(text === undefined) text = tagObj[property];
|
|
else text += "" + tagObj[property];
|
|
}else if(property === undefined){
|
|
continue;
|
|
}else if(tagObj[property]){
|
|
|
|
let val = compress(tagObj[property], options, newJpath);
|
|
const isLeaf = isLeafTag(val, options);
|
|
|
|
if(tagObj[":@"]){
|
|
assignAttributes( val, tagObj[":@"], newJpath, options);
|
|
}else if(Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode){
|
|
val = val[options.textNodeName];
|
|
}else if(Object.keys(val).length === 0){
|
|
if(options.alwaysCreateTextNode) val[options.textNodeName] = "";
|
|
else val = "";
|
|
}
|
|
|
|
if(compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
|
|
if(!Array.isArray(compressedObj[property])) {
|
|
compressedObj[property] = [ compressedObj[property] ];
|
|
}
|
|
compressedObj[property].push(val);
|
|
}else {
|
|
//TODO: if a node is not an array, then check if it should be an array
|
|
//also determine if it is a leaf node
|
|
if (options.isArray(property, newJpath, isLeaf )) {
|
|
compressedObj[property] = [val];
|
|
}else {
|
|
compressedObj[property] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
// if(text && text.length > 0) compressedObj[options.textNodeName] = text;
|
|
if(typeof text === "string"){
|
|
if(text.length > 0) compressedObj[options.textNodeName] = text;
|
|
}else if(text !== undefined) compressedObj[options.textNodeName] = text;
|
|
return compressedObj;
|
|
}
|
|
|
|
function propName$1(obj){
|
|
const keys = Object.keys(obj);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
if(key !== ":@") return key;
|
|
}
|
|
}
|
|
|
|
function assignAttributes(obj, attrMap, jpath, options){
|
|
if (attrMap) {
|
|
const keys = Object.keys(attrMap);
|
|
const len = keys.length; //don't make it inline
|
|
for (let i = 0; i < len; i++) {
|
|
const atrrName = keys[i];
|
|
if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
|
|
obj[atrrName] = [ attrMap[atrrName] ];
|
|
} else {
|
|
obj[atrrName] = attrMap[atrrName];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function isLeafTag(obj, options){
|
|
const { textNodeName } = options;
|
|
const propCount = Object.keys(obj).length;
|
|
|
|
if (propCount === 0) {
|
|
return true;
|
|
}
|
|
|
|
if (
|
|
propCount === 1 &&
|
|
(obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
node2json.prettify = prettify$1;
|
|
|
|
const { buildOptions} = OptionsBuilder;
|
|
const OrderedObjParser = OrderedObjParser_1;
|
|
const { prettify} = node2json;
|
|
const validator$1 = validator$2;
|
|
|
|
class XMLParser$2{
|
|
|
|
constructor(options){
|
|
this.externalEntities = {};
|
|
this.options = buildOptions(options);
|
|
|
|
}
|
|
/**
|
|
* Parse XML dats to JS object
|
|
* @param {string|Buffer} xmlData
|
|
* @param {boolean|Object} validationOption
|
|
*/
|
|
parse(xmlData,validationOption){
|
|
if(typeof xmlData === "string");else if( xmlData.toString){
|
|
xmlData = xmlData.toString();
|
|
}else {
|
|
throw new Error("XML data is accepted in String or Bytes[] form.")
|
|
}
|
|
if( validationOption){
|
|
if(validationOption === true) validationOption = {}; //validate with default options
|
|
|
|
const result = validator$1.validate(xmlData, validationOption);
|
|
if (result !== true) {
|
|
throw Error( `${result.err.msg}:${result.err.line}:${result.err.col}` )
|
|
}
|
|
}
|
|
const orderedObjParser = new OrderedObjParser(this.options);
|
|
orderedObjParser.addExternalEntities(this.externalEntities);
|
|
const orderedResult = orderedObjParser.parseXml(xmlData);
|
|
if(this.options.preserveOrder || orderedResult === undefined) return orderedResult;
|
|
else return prettify(orderedResult, this.options);
|
|
}
|
|
|
|
/**
|
|
* Add Entity which is not by default supported by this library
|
|
* @param {string} key
|
|
* @param {string} value
|
|
*/
|
|
addEntity(key, value){
|
|
if(value.indexOf("&") !== -1){
|
|
throw new Error("Entity value can't have '&'")
|
|
}else if(key.indexOf("&") !== -1 || key.indexOf(";") !== -1){
|
|
throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'")
|
|
}else if(value === "&"){
|
|
throw new Error("An entity with value '&' is not permitted");
|
|
}else {
|
|
this.externalEntities[key] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
var XMLParser_1 = XMLParser$2;
|
|
|
|
const EOL = "\n";
|
|
|
|
/**
|
|
*
|
|
* @param {array} jArray
|
|
* @param {any} options
|
|
* @returns
|
|
*/
|
|
function toXml(jArray, options) {
|
|
let indentation = "";
|
|
if (options.format && options.indentBy.length > 0) {
|
|
indentation = EOL;
|
|
}
|
|
return arrToStr(jArray, options, "", indentation);
|
|
}
|
|
|
|
function arrToStr(arr, options, jPath, indentation) {
|
|
let xmlStr = "";
|
|
let isPreviousElementTag = false;
|
|
|
|
for (let i = 0; i < arr.length; i++) {
|
|
const tagObj = arr[i];
|
|
const tagName = propName(tagObj);
|
|
if(tagName === undefined) continue;
|
|
|
|
let newJPath = "";
|
|
if (jPath.length === 0) newJPath = tagName;
|
|
else newJPath = `${jPath}.${tagName}`;
|
|
|
|
if (tagName === options.textNodeName) {
|
|
let tagText = tagObj[tagName];
|
|
if (!isStopNode(newJPath, options)) {
|
|
tagText = options.tagValueProcessor(tagName, tagText);
|
|
tagText = replaceEntitiesValue(tagText, options);
|
|
}
|
|
if (isPreviousElementTag) {
|
|
xmlStr += indentation;
|
|
}
|
|
xmlStr += tagText;
|
|
isPreviousElementTag = false;
|
|
continue;
|
|
} else if (tagName === options.cdataPropName) {
|
|
if (isPreviousElementTag) {
|
|
xmlStr += indentation;
|
|
}
|
|
xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
|
|
isPreviousElementTag = false;
|
|
continue;
|
|
} else if (tagName === options.commentPropName) {
|
|
xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
|
|
isPreviousElementTag = true;
|
|
continue;
|
|
} else if (tagName[0] === "?") {
|
|
const attStr = attr_to_str(tagObj[":@"], options);
|
|
const tempInd = tagName === "?xml" ? "" : indentation;
|
|
let piTextNodeName = tagObj[tagName][0][options.textNodeName];
|
|
piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : ""; //remove extra spacing
|
|
xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr}?>`;
|
|
isPreviousElementTag = true;
|
|
continue;
|
|
}
|
|
let newIdentation = indentation;
|
|
if (newIdentation !== "") {
|
|
newIdentation += options.indentBy;
|
|
}
|
|
const attStr = attr_to_str(tagObj[":@"], options);
|
|
const tagStart = indentation + `<${tagName}${attStr}`;
|
|
const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
|
|
if (options.unpairedTags.indexOf(tagName) !== -1) {
|
|
if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
|
|
else xmlStr += tagStart + "/>";
|
|
} else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
|
|
xmlStr += tagStart + "/>";
|
|
} else if (tagValue && tagValue.endsWith(">")) {
|
|
xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
|
|
} else {
|
|
xmlStr += tagStart + ">";
|
|
if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) {
|
|
xmlStr += indentation + options.indentBy + tagValue + indentation;
|
|
} else {
|
|
xmlStr += tagValue;
|
|
}
|
|
xmlStr += `</${tagName}>`;
|
|
}
|
|
isPreviousElementTag = true;
|
|
}
|
|
|
|
return xmlStr;
|
|
}
|
|
|
|
function propName(obj) {
|
|
const keys = Object.keys(obj);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
const key = keys[i];
|
|
if(!obj.hasOwnProperty(key)) continue;
|
|
if (key !== ":@") return key;
|
|
}
|
|
}
|
|
|
|
function attr_to_str(attrMap, options) {
|
|
let attrStr = "";
|
|
if (attrMap && !options.ignoreAttributes) {
|
|
for (let attr in attrMap) {
|
|
if(!attrMap.hasOwnProperty(attr)) continue;
|
|
let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
|
|
attrVal = replaceEntitiesValue(attrVal, options);
|
|
if (attrVal === true && options.suppressBooleanAttributes) {
|
|
attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
|
|
} else {
|
|
attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
|
|
}
|
|
}
|
|
}
|
|
return attrStr;
|
|
}
|
|
|
|
function isStopNode(jPath, options) {
|
|
jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
|
|
let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
|
|
for (let index in options.stopNodes) {
|
|
if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function replaceEntitiesValue(textValue, options) {
|
|
if (textValue && textValue.length > 0 && options.processEntities) {
|
|
for (let i = 0; i < options.entities.length; i++) {
|
|
const entity = options.entities[i];
|
|
textValue = textValue.replace(entity.regex, entity.val);
|
|
}
|
|
}
|
|
return textValue;
|
|
}
|
|
var orderedJs2Xml = toXml;
|
|
|
|
//parse Empty Node as self closing node
|
|
const buildFromOrderedJs = orderedJs2Xml;
|
|
const getIgnoreAttributesFn = ignoreAttributes;
|
|
|
|
const defaultOptions = {
|
|
attributeNamePrefix: '@_',
|
|
attributesGroupName: false,
|
|
textNodeName: '#text',
|
|
ignoreAttributes: true,
|
|
cdataPropName: false,
|
|
format: false,
|
|
indentBy: ' ',
|
|
suppressEmptyNode: false,
|
|
suppressUnpairedNode: true,
|
|
suppressBooleanAttributes: true,
|
|
tagValueProcessor: function(key, a) {
|
|
return a;
|
|
},
|
|
attributeValueProcessor: function(attrName, a) {
|
|
return a;
|
|
},
|
|
preserveOrder: false,
|
|
commentPropName: false,
|
|
unpairedTags: [],
|
|
entities: [
|
|
{ regex: new RegExp("&", "g"), val: "&" },//it must be on top
|
|
{ regex: new RegExp(">", "g"), val: ">" },
|
|
{ regex: new RegExp("<", "g"), val: "<" },
|
|
{ regex: new RegExp("\'", "g"), val: "'" },
|
|
{ regex: new RegExp("\"", "g"), val: """ }
|
|
],
|
|
processEntities: true,
|
|
stopNodes: [],
|
|
// transformTagName: false,
|
|
// transformAttributeName: false,
|
|
oneListGroup: false
|
|
};
|
|
|
|
function Builder(options) {
|
|
this.options = Object.assign({}, defaultOptions, options);
|
|
if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
|
|
this.isAttribute = function(/*a*/) {
|
|
return false;
|
|
};
|
|
} else {
|
|
this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
|
|
this.attrPrefixLen = this.options.attributeNamePrefix.length;
|
|
this.isAttribute = isAttribute;
|
|
}
|
|
|
|
this.processTextOrObjNode = processTextOrObjNode;
|
|
|
|
if (this.options.format) {
|
|
this.indentate = indentate;
|
|
this.tagEndChar = '>\n';
|
|
this.newLine = '\n';
|
|
} else {
|
|
this.indentate = function() {
|
|
return '';
|
|
};
|
|
this.tagEndChar = '>';
|
|
this.newLine = '';
|
|
}
|
|
}
|
|
|
|
Builder.prototype.build = function(jObj) {
|
|
if(this.options.preserveOrder){
|
|
return buildFromOrderedJs(jObj, this.options);
|
|
}else {
|
|
if(Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1){
|
|
jObj = {
|
|
[this.options.arrayNodeName] : jObj
|
|
};
|
|
}
|
|
return this.j2x(jObj, 0, []).val;
|
|
}
|
|
};
|
|
|
|
Builder.prototype.j2x = function(jObj, level, ajPath) {
|
|
let attrStr = '';
|
|
let val = '';
|
|
const jPath = ajPath.join('.');
|
|
for (let key in jObj) {
|
|
if(!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
|
|
if (typeof jObj[key] === 'undefined') {
|
|
// supress undefined node only if it is not an attribute
|
|
if (this.isAttribute(key)) {
|
|
val += '';
|
|
}
|
|
} else if (jObj[key] === null) {
|
|
// null attribute should be ignored by the attribute list, but should not cause the tag closing
|
|
if (this.isAttribute(key)) {
|
|
val += '';
|
|
} else if (key === this.options.cdataPropName) {
|
|
val += '';
|
|
} else if (key[0] === '?') {
|
|
val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
|
|
} else {
|
|
val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
|
|
}
|
|
// val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
|
|
} else if (jObj[key] instanceof Date) {
|
|
val += this.buildTextValNode(jObj[key], key, '', level);
|
|
} else if (typeof jObj[key] !== 'object') {
|
|
//premitive type
|
|
const attr = this.isAttribute(key);
|
|
if (attr && !this.ignoreAttributesFn(attr, jPath)) {
|
|
attrStr += this.buildAttrPairStr(attr, '' + jObj[key]);
|
|
} else if (!attr) {
|
|
//tag value
|
|
if (key === this.options.textNodeName) {
|
|
let newval = this.options.tagValueProcessor(key, '' + jObj[key]);
|
|
val += this.replaceEntitiesValue(newval);
|
|
} else {
|
|
val += this.buildTextValNode(jObj[key], key, '', level);
|
|
}
|
|
}
|
|
} else if (Array.isArray(jObj[key])) {
|
|
//repeated nodes
|
|
const arrLen = jObj[key].length;
|
|
let listTagVal = "";
|
|
let listTagAttr = "";
|
|
for (let j = 0; j < arrLen; j++) {
|
|
const item = jObj[key][j];
|
|
if (typeof item === 'undefined') ; else if (item === null) {
|
|
if(key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;
|
|
else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
|
|
// val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
|
|
} else if (typeof item === 'object') {
|
|
if(this.options.oneListGroup){
|
|
const result = this.j2x(item, level + 1, ajPath.concat(key));
|
|
listTagVal += result.val;
|
|
if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {
|
|
listTagAttr += result.attrStr;
|
|
}
|
|
}else {
|
|
listTagVal += this.processTextOrObjNode(item, key, level, ajPath);
|
|
}
|
|
} else {
|
|
if (this.options.oneListGroup) {
|
|
let textValue = this.options.tagValueProcessor(key, item);
|
|
textValue = this.replaceEntitiesValue(textValue);
|
|
listTagVal += textValue;
|
|
} else {
|
|
listTagVal += this.buildTextValNode(item, key, '', level);
|
|
}
|
|
}
|
|
}
|
|
if(this.options.oneListGroup){
|
|
listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
|
|
}
|
|
val += listTagVal;
|
|
} else {
|
|
//nested node
|
|
if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
|
|
const Ks = Object.keys(jObj[key]);
|
|
const L = Ks.length;
|
|
for (let j = 0; j < L; j++) {
|
|
attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]]);
|
|
}
|
|
} else {
|
|
val += this.processTextOrObjNode(jObj[key], key, level, ajPath);
|
|
}
|
|
}
|
|
}
|
|
return {attrStr: attrStr, val: val};
|
|
};
|
|
|
|
Builder.prototype.buildAttrPairStr = function(attrName, val){
|
|
val = this.options.attributeValueProcessor(attrName, '' + val);
|
|
val = this.replaceEntitiesValue(val);
|
|
if (this.options.suppressBooleanAttributes && val === "true") {
|
|
return ' ' + attrName;
|
|
} else return ' ' + attrName + '="' + val + '"';
|
|
};
|
|
|
|
function processTextOrObjNode (object, key, level, ajPath) {
|
|
const result = this.j2x(object, level + 1, ajPath.concat(key));
|
|
if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {
|
|
return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
|
|
} else {
|
|
return this.buildObjectNode(result.val, key, result.attrStr, level);
|
|
}
|
|
}
|
|
|
|
Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
|
|
if(val === ""){
|
|
if(key[0] === "?") return this.indentate(level) + '<' + key + attrStr+ '?' + this.tagEndChar;
|
|
else {
|
|
return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
|
|
}
|
|
}else {
|
|
|
|
let tagEndExp = '</' + key + this.tagEndChar;
|
|
let piClosingChar = "";
|
|
|
|
if(key[0] === "?") {
|
|
piClosingChar = "?";
|
|
tagEndExp = "";
|
|
}
|
|
|
|
// attrStr is an empty string in case the attribute came as undefined or null
|
|
if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {
|
|
return ( this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp );
|
|
} else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
|
|
return this.indentate(level) + `<!--${val}-->` + this.newLine;
|
|
}else {
|
|
return (
|
|
this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +
|
|
val +
|
|
this.indentate(level) + tagEndExp );
|
|
}
|
|
}
|
|
};
|
|
|
|
Builder.prototype.closeTag = function(key){
|
|
let closeTag = "";
|
|
if(this.options.unpairedTags.indexOf(key) !== -1){ //unpaired
|
|
if(!this.options.suppressUnpairedNode) closeTag = "/";
|
|
}else if(this.options.suppressEmptyNode){ //empty
|
|
closeTag = "/";
|
|
}else {
|
|
closeTag = `></${key}`;
|
|
}
|
|
return closeTag;
|
|
};
|
|
|
|
Builder.prototype.buildTextValNode = function(val, key, attrStr, level) {
|
|
if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
|
|
return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
|
|
}else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
|
|
return this.indentate(level) + `<!--${val}-->` + this.newLine;
|
|
}else if(key[0] === "?") {//PI tag
|
|
return this.indentate(level) + '<' + key + attrStr+ '?' + this.tagEndChar;
|
|
}else {
|
|
let textValue = this.options.tagValueProcessor(key, val);
|
|
textValue = this.replaceEntitiesValue(textValue);
|
|
|
|
if( textValue === ''){
|
|
return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;
|
|
}else {
|
|
return this.indentate(level) + '<' + key + attrStr + '>' +
|
|
textValue +
|
|
'</' + key + this.tagEndChar;
|
|
}
|
|
}
|
|
};
|
|
|
|
Builder.prototype.replaceEntitiesValue = function(textValue){
|
|
if(textValue && textValue.length > 0 && this.options.processEntities){
|
|
for (let i=0; i<this.options.entities.length; i++) {
|
|
const entity = this.options.entities[i];
|
|
textValue = textValue.replace(entity.regex, entity.val);
|
|
}
|
|
}
|
|
return textValue;
|
|
};
|
|
|
|
function indentate(level) {
|
|
return this.options.indentBy.repeat(level);
|
|
}
|
|
|
|
function isAttribute(name /*, options*/) {
|
|
if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {
|
|
return name.substr(this.attrPrefixLen);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var json2xml = Builder;
|
|
|
|
const validator = validator$2;
|
|
const XMLParser$1 = XMLParser_1;
|
|
const XMLBuilder = json2xml;
|
|
|
|
var fxp = {
|
|
XMLParser: XMLParser$1,
|
|
XMLValidator: validator,
|
|
XMLBuilder: XMLBuilder
|
|
};
|
|
|
|
const {XMLParser, XMLValidator} = fxp;
|
|
|
|
const isSvg = input => {
|
|
if (input === undefined || input === null) {
|
|
return false;
|
|
}
|
|
|
|
input = input.toString().trim();
|
|
|
|
if (input.length === 0) {
|
|
return false;
|
|
}
|
|
|
|
// Has to be `!==` as it can also return an object with error info.
|
|
if (XMLValidator.validate(input) !== true) {
|
|
return false;
|
|
}
|
|
|
|
let jsonObject;
|
|
const parser = new XMLParser();
|
|
|
|
try {
|
|
jsonObject = parser.parse(input);
|
|
} catch (_) {
|
|
return false;
|
|
}
|
|
|
|
if (!jsonObject) {
|
|
return false;
|
|
}
|
|
|
|
if (!('svg' in jsonObject)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
isSvg$2.exports = isSvg;
|
|
// TODO: Remove this for the next major release
|
|
isSvg$2.exports.default = isSvg;
|
|
|
|
var isSvgExports = isSvg$2.exports;
|
|
var isSvg$1 = /*@__PURE__*/getDefaultExportFromCjs(isSvgExports);
|
|
|
|
var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
|
|
|
|
var escapeStringRegexp$2 = function (str) {
|
|
if (typeof str !== 'string') {
|
|
throw new TypeError('Expected a string');
|
|
}
|
|
|
|
return str.replace(matchOperatorsRe, '\\$&');
|
|
};
|
|
|
|
var escapeStringRegexp$1 = escapeStringRegexp$2;
|
|
|
|
var trimRepeated = function (str, target) {
|
|
if (typeof str !== 'string' || typeof target !== 'string') {
|
|
throw new TypeError('Expected a string');
|
|
}
|
|
|
|
return str.replace(new RegExp('(?:' + escapeStringRegexp$1(target) + '){2,}', 'g'), target);
|
|
};
|
|
|
|
var trimRepeated$1 = /*@__PURE__*/getDefaultExportFromCjs(trimRepeated);
|
|
|
|
var filenameReservedRegex$1 = {exports: {}};
|
|
|
|
/* eslint-disable no-control-regex */
|
|
// TODO: remove parens when Node.js 6 is targeted. Node.js 4 barfs at it.
|
|
filenameReservedRegex$1.exports = () => (/[<>:"\/\\|?*\x00-\x1F]/g);
|
|
filenameReservedRegex$1.exports.windowsNames = () => (/^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i);
|
|
|
|
var filenameReservedRegexExports = filenameReservedRegex$1.exports;
|
|
var filenameReservedRegex = /*@__PURE__*/getDefaultExportFromCjs(filenameReservedRegexExports);
|
|
|
|
var escapeStringRegexp = escapeStringRegexp$2;
|
|
|
|
var stripOuter = function (str, sub) {
|
|
if (typeof str !== 'string' || typeof sub !== 'string') {
|
|
throw new TypeError();
|
|
}
|
|
|
|
sub = escapeStringRegexp(sub);
|
|
return str.replace(new RegExp('^' + sub + '|' + sub + '$', 'g'), '');
|
|
};
|
|
|
|
var stripOuter$1 = /*@__PURE__*/getDefaultExportFromCjs(stripOuter);
|
|
|
|
// Doesn't make sense to have longer filenames
|
|
const MAX_FILENAME_LENGTH = 100;
|
|
|
|
const reControlChars = /[\u0000-\u001F\u0080-\u009F]/g; // eslint-disable-line no-control-regex
|
|
const reRelativePath = /^\.+/;
|
|
const reTrailingPeriods = /\.+$/;
|
|
|
|
function filenamify(string, options = {}) {
|
|
if (typeof string !== 'string') {
|
|
throw new TypeError('Expected a string');
|
|
}
|
|
|
|
const replacement = options.replacement === undefined ? '!' : options.replacement;
|
|
|
|
if (filenameReservedRegex().test(replacement) && reControlChars.test(replacement)) {
|
|
throw new Error('Replacement string cannot contain reserved filename characters');
|
|
}
|
|
|
|
string = string.replace(filenameReservedRegex(), replacement);
|
|
string = string.replace(reControlChars, replacement);
|
|
string = string.replace(reRelativePath, replacement);
|
|
string = string.replace(reTrailingPeriods, '');
|
|
|
|
if (replacement.length > 0) {
|
|
string = trimRepeated$1(string, replacement);
|
|
string = string.length > 1 ? stripOuter$1(string, replacement) : string;
|
|
}
|
|
|
|
string = filenameReservedRegex.windowsNames().test(string) ? string + replacement : string;
|
|
string = string.slice(0, typeof options.maxLength === 'number' ? options.maxLength : MAX_FILENAME_LENGTH);
|
|
|
|
return string;
|
|
}
|
|
|
|
var md5$1 = {exports: {}};
|
|
|
|
function commonjsRequire(path) {
|
|
throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
|
|
}
|
|
|
|
var core = {exports: {}};
|
|
|
|
var _nodeResolve_empty = {};
|
|
|
|
var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
'default': _nodeResolve_empty
|
|
});
|
|
|
|
var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
|
|
|
|
core.exports;
|
|
|
|
var hasRequiredCore;
|
|
|
|
function requireCore () {
|
|
if (hasRequiredCore) return core.exports;
|
|
hasRequiredCore = 1;
|
|
(function (module, exports) {
|
|
(function (root, factory) {
|
|
{
|
|
// CommonJS
|
|
module.exports = factory();
|
|
}
|
|
}(commonjsGlobal, function () {
|
|
|
|
/*globals window, global, require*/
|
|
|
|
/**
|
|
* CryptoJS core components.
|
|
*/
|
|
var CryptoJS = CryptoJS || (function (Math, undefined$1) {
|
|
|
|
var crypto;
|
|
|
|
// Native crypto from window (Browser)
|
|
if (typeof window !== 'undefined' && window.crypto) {
|
|
crypto = window.crypto;
|
|
}
|
|
|
|
// Native crypto in web worker (Browser)
|
|
if (typeof self !== 'undefined' && self.crypto) {
|
|
crypto = self.crypto;
|
|
}
|
|
|
|
// Native crypto from worker
|
|
if (typeof globalThis !== 'undefined' && globalThis.crypto) {
|
|
crypto = globalThis.crypto;
|
|
}
|
|
|
|
// Native (experimental IE 11) crypto from window (Browser)
|
|
if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
|
|
crypto = window.msCrypto;
|
|
}
|
|
|
|
// Native crypto from global (NodeJS)
|
|
if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
|
|
crypto = commonjsGlobal.crypto;
|
|
}
|
|
|
|
// Native crypto import via require (NodeJS)
|
|
if (!crypto && typeof commonjsRequire === 'function') {
|
|
try {
|
|
crypto = require$$0;
|
|
} catch (err) {}
|
|
}
|
|
|
|
/*
|
|
* Cryptographically secure pseudorandom number generator
|
|
*
|
|
* As Math.random() is cryptographically not safe to use
|
|
*/
|
|
var cryptoSecureRandomInt = function () {
|
|
if (crypto) {
|
|
// Use getRandomValues method (Browser)
|
|
if (typeof crypto.getRandomValues === 'function') {
|
|
try {
|
|
return crypto.getRandomValues(new Uint32Array(1))[0];
|
|
} catch (err) {}
|
|
}
|
|
|
|
// Use randomBytes method (NodeJS)
|
|
if (typeof crypto.randomBytes === 'function') {
|
|
try {
|
|
return crypto.randomBytes(4).readInt32LE();
|
|
} catch (err) {}
|
|
}
|
|
}
|
|
|
|
throw new Error('Native crypto module could not be used to get secure random number.');
|
|
};
|
|
|
|
/*
|
|
* Local polyfill of Object.create
|
|
|
|
*/
|
|
var create = Object.create || (function () {
|
|
function F() {}
|
|
|
|
return function (obj) {
|
|
var subtype;
|
|
|
|
F.prototype = obj;
|
|
|
|
subtype = new F();
|
|
|
|
F.prototype = null;
|
|
|
|
return subtype;
|
|
};
|
|
}());
|
|
|
|
/**
|
|
* CryptoJS namespace.
|
|
*/
|
|
var C = {};
|
|
|
|
/**
|
|
* Library namespace.
|
|
*/
|
|
var C_lib = C.lib = {};
|
|
|
|
/**
|
|
* Base object for prototypal inheritance.
|
|
*/
|
|
var Base = C_lib.Base = (function () {
|
|
|
|
|
|
return {
|
|
/**
|
|
* Creates a new object that inherits from this object.
|
|
*
|
|
* @param {Object} overrides Properties to copy into the new object.
|
|
*
|
|
* @return {Object} The new object.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var MyType = CryptoJS.lib.Base.extend({
|
|
* field: 'value',
|
|
*
|
|
* method: function () {
|
|
* }
|
|
* });
|
|
*/
|
|
extend: function (overrides) {
|
|
// Spawn
|
|
var subtype = create(this);
|
|
|
|
// Augment
|
|
if (overrides) {
|
|
subtype.mixIn(overrides);
|
|
}
|
|
|
|
// Create default initializer
|
|
if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
|
|
subtype.init = function () {
|
|
subtype.$super.init.apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
// Initializer's prototype is the subtype object
|
|
subtype.init.prototype = subtype;
|
|
|
|
// Reference supertype
|
|
subtype.$super = this;
|
|
|
|
return subtype;
|
|
},
|
|
|
|
/**
|
|
* Extends this object and runs the init method.
|
|
* Arguments to create() will be passed to init().
|
|
*
|
|
* @return {Object} The new object.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var instance = MyType.create();
|
|
*/
|
|
create: function () {
|
|
var instance = this.extend();
|
|
instance.init.apply(instance, arguments);
|
|
|
|
return instance;
|
|
},
|
|
|
|
/**
|
|
* Initializes a newly created object.
|
|
* Override this method to add some logic when your objects are created.
|
|
*
|
|
* @example
|
|
*
|
|
* var MyType = CryptoJS.lib.Base.extend({
|
|
* init: function () {
|
|
* // ...
|
|
* }
|
|
* });
|
|
*/
|
|
init: function () {
|
|
},
|
|
|
|
/**
|
|
* Copies properties into this object.
|
|
*
|
|
* @param {Object} properties The properties to mix in.
|
|
*
|
|
* @example
|
|
*
|
|
* MyType.mixIn({
|
|
* field: 'value'
|
|
* });
|
|
*/
|
|
mixIn: function (properties) {
|
|
for (var propertyName in properties) {
|
|
if (properties.hasOwnProperty(propertyName)) {
|
|
this[propertyName] = properties[propertyName];
|
|
}
|
|
}
|
|
|
|
// IE won't copy toString using the loop above
|
|
if (properties.hasOwnProperty('toString')) {
|
|
this.toString = properties.toString;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Creates a copy of this object.
|
|
*
|
|
* @return {Object} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = instance.clone();
|
|
*/
|
|
clone: function () {
|
|
return this.init.prototype.extend(this);
|
|
}
|
|
};
|
|
}());
|
|
|
|
/**
|
|
* An array of 32-bit words.
|
|
*
|
|
* @property {Array} words The array of 32-bit words.
|
|
* @property {number} sigBytes The number of significant bytes in this word array.
|
|
*/
|
|
var WordArray = C_lib.WordArray = Base.extend({
|
|
/**
|
|
* Initializes a newly created word array.
|
|
*
|
|
* @param {Array} words (Optional) An array of 32-bit words.
|
|
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.lib.WordArray.create();
|
|
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
|
|
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
|
|
*/
|
|
init: function (words, sigBytes) {
|
|
words = this.words = words || [];
|
|
|
|
if (sigBytes != undefined$1) {
|
|
this.sigBytes = sigBytes;
|
|
} else {
|
|
this.sigBytes = words.length * 4;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Converts this word array to a string.
|
|
*
|
|
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
|
|
*
|
|
* @return {string} The stringified word array.
|
|
*
|
|
* @example
|
|
*
|
|
* var string = wordArray + '';
|
|
* var string = wordArray.toString();
|
|
* var string = wordArray.toString(CryptoJS.enc.Utf8);
|
|
*/
|
|
toString: function (encoder) {
|
|
return (encoder || Hex).stringify(this);
|
|
},
|
|
|
|
/**
|
|
* Concatenates a word array to this word array.
|
|
*
|
|
* @param {WordArray} wordArray The word array to append.
|
|
*
|
|
* @return {WordArray} This word array.
|
|
*
|
|
* @example
|
|
*
|
|
* wordArray1.concat(wordArray2);
|
|
*/
|
|
concat: function (wordArray) {
|
|
// Shortcuts
|
|
var thisWords = this.words;
|
|
var thatWords = wordArray.words;
|
|
var thisSigBytes = this.sigBytes;
|
|
var thatSigBytes = wordArray.sigBytes;
|
|
|
|
// Clamp excess bits
|
|
this.clamp();
|
|
|
|
// Concat
|
|
if (thisSigBytes % 4) {
|
|
// Copy one byte at a time
|
|
for (var i = 0; i < thatSigBytes; i++) {
|
|
var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
|
thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
|
|
}
|
|
} else {
|
|
// Copy one word at a time
|
|
for (var j = 0; j < thatSigBytes; j += 4) {
|
|
thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];
|
|
}
|
|
}
|
|
this.sigBytes += thatSigBytes;
|
|
|
|
// Chainable
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Removes insignificant bits.
|
|
*
|
|
* @example
|
|
*
|
|
* wordArray.clamp();
|
|
*/
|
|
clamp: function () {
|
|
// Shortcuts
|
|
var words = this.words;
|
|
var sigBytes = this.sigBytes;
|
|
|
|
// Clamp
|
|
words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
|
|
words.length = Math.ceil(sigBytes / 4);
|
|
},
|
|
|
|
/**
|
|
* Creates a copy of this word array.
|
|
*
|
|
* @return {WordArray} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = wordArray.clone();
|
|
*/
|
|
clone: function () {
|
|
var clone = Base.clone.call(this);
|
|
clone.words = this.words.slice(0);
|
|
|
|
return clone;
|
|
},
|
|
|
|
/**
|
|
* Creates a word array filled with random bytes.
|
|
*
|
|
* @param {number} nBytes The number of random bytes to generate.
|
|
*
|
|
* @return {WordArray} The random word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.lib.WordArray.random(16);
|
|
*/
|
|
random: function (nBytes) {
|
|
var words = [];
|
|
|
|
for (var i = 0; i < nBytes; i += 4) {
|
|
words.push(cryptoSecureRandomInt());
|
|
}
|
|
|
|
return new WordArray.init(words, nBytes);
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Encoder namespace.
|
|
*/
|
|
var C_enc = C.enc = {};
|
|
|
|
/**
|
|
* Hex encoding strategy.
|
|
*/
|
|
var Hex = C_enc.Hex = {
|
|
/**
|
|
* Converts a word array to a hex string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The hex string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
|
|
*/
|
|
stringify: function (wordArray) {
|
|
// Shortcuts
|
|
var words = wordArray.words;
|
|
var sigBytes = wordArray.sigBytes;
|
|
|
|
// Convert
|
|
var hexChars = [];
|
|
for (var i = 0; i < sigBytes; i++) {
|
|
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
|
hexChars.push((bite >>> 4).toString(16));
|
|
hexChars.push((bite & 0x0f).toString(16));
|
|
}
|
|
|
|
return hexChars.join('');
|
|
},
|
|
|
|
/**
|
|
* Converts a hex string to a word array.
|
|
*
|
|
* @param {string} hexStr The hex string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
|
|
*/
|
|
parse: function (hexStr) {
|
|
// Shortcut
|
|
var hexStrLength = hexStr.length;
|
|
|
|
// Convert
|
|
var words = [];
|
|
for (var i = 0; i < hexStrLength; i += 2) {
|
|
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
|
|
}
|
|
|
|
return new WordArray.init(words, hexStrLength / 2);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Latin1 encoding strategy.
|
|
*/
|
|
var Latin1 = C_enc.Latin1 = {
|
|
/**
|
|
* Converts a word array to a Latin1 string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The Latin1 string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
|
|
*/
|
|
stringify: function (wordArray) {
|
|
// Shortcuts
|
|
var words = wordArray.words;
|
|
var sigBytes = wordArray.sigBytes;
|
|
|
|
// Convert
|
|
var latin1Chars = [];
|
|
for (var i = 0; i < sigBytes; i++) {
|
|
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
|
|
latin1Chars.push(String.fromCharCode(bite));
|
|
}
|
|
|
|
return latin1Chars.join('');
|
|
},
|
|
|
|
/**
|
|
* Converts a Latin1 string to a word array.
|
|
*
|
|
* @param {string} latin1Str The Latin1 string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
|
|
*/
|
|
parse: function (latin1Str) {
|
|
// Shortcut
|
|
var latin1StrLength = latin1Str.length;
|
|
|
|
// Convert
|
|
var words = [];
|
|
for (var i = 0; i < latin1StrLength; i++) {
|
|
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
|
|
}
|
|
|
|
return new WordArray.init(words, latin1StrLength);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* UTF-8 encoding strategy.
|
|
*/
|
|
var Utf8 = C_enc.Utf8 = {
|
|
/**
|
|
* Converts a word array to a UTF-8 string.
|
|
*
|
|
* @param {WordArray} wordArray The word array.
|
|
*
|
|
* @return {string} The UTF-8 string.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
|
|
*/
|
|
stringify: function (wordArray) {
|
|
try {
|
|
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
|
|
} catch (e) {
|
|
throw new Error('Malformed UTF-8 data');
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Converts a UTF-8 string to a word array.
|
|
*
|
|
* @param {string} utf8Str The UTF-8 string.
|
|
*
|
|
* @return {WordArray} The word array.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
|
|
*/
|
|
parse: function (utf8Str) {
|
|
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Abstract buffered block algorithm template.
|
|
*
|
|
* The property blockSize must be implemented in a concrete subtype.
|
|
*
|
|
* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
|
|
*/
|
|
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
|
|
/**
|
|
* Resets this block algorithm's data buffer to its initial state.
|
|
*
|
|
* @example
|
|
*
|
|
* bufferedBlockAlgorithm.reset();
|
|
*/
|
|
reset: function () {
|
|
// Initial values
|
|
this._data = new WordArray.init();
|
|
this._nDataBytes = 0;
|
|
},
|
|
|
|
/**
|
|
* Adds new data to this block algorithm's buffer.
|
|
*
|
|
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
|
|
*
|
|
* @example
|
|
*
|
|
* bufferedBlockAlgorithm._append('data');
|
|
* bufferedBlockAlgorithm._append(wordArray);
|
|
*/
|
|
_append: function (data) {
|
|
// Convert string to WordArray, else assume WordArray already
|
|
if (typeof data == 'string') {
|
|
data = Utf8.parse(data);
|
|
}
|
|
|
|
// Append
|
|
this._data.concat(data);
|
|
this._nDataBytes += data.sigBytes;
|
|
},
|
|
|
|
/**
|
|
* Processes available data blocks.
|
|
*
|
|
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
|
|
*
|
|
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
|
|
*
|
|
* @return {WordArray} The processed data.
|
|
*
|
|
* @example
|
|
*
|
|
* var processedData = bufferedBlockAlgorithm._process();
|
|
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
|
|
*/
|
|
_process: function (doFlush) {
|
|
var processedWords;
|
|
|
|
// Shortcuts
|
|
var data = this._data;
|
|
var dataWords = data.words;
|
|
var dataSigBytes = data.sigBytes;
|
|
var blockSize = this.blockSize;
|
|
var blockSizeBytes = blockSize * 4;
|
|
|
|
// Count blocks ready
|
|
var nBlocksReady = dataSigBytes / blockSizeBytes;
|
|
if (doFlush) {
|
|
// Round up to include partial blocks
|
|
nBlocksReady = Math.ceil(nBlocksReady);
|
|
} else {
|
|
// Round down to include only full blocks,
|
|
// less the number of blocks that must remain in the buffer
|
|
nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
|
|
}
|
|
|
|
// Count words ready
|
|
var nWordsReady = nBlocksReady * blockSize;
|
|
|
|
// Count bytes ready
|
|
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
|
|
|
|
// Process blocks
|
|
if (nWordsReady) {
|
|
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
|
|
// Perform concrete-algorithm logic
|
|
this._doProcessBlock(dataWords, offset);
|
|
}
|
|
|
|
// Remove processed words
|
|
processedWords = dataWords.splice(0, nWordsReady);
|
|
data.sigBytes -= nBytesReady;
|
|
}
|
|
|
|
// Return processed words
|
|
return new WordArray.init(processedWords, nBytesReady);
|
|
},
|
|
|
|
/**
|
|
* Creates a copy of this object.
|
|
*
|
|
* @return {Object} The clone.
|
|
*
|
|
* @example
|
|
*
|
|
* var clone = bufferedBlockAlgorithm.clone();
|
|
*/
|
|
clone: function () {
|
|
var clone = Base.clone.call(this);
|
|
clone._data = this._data.clone();
|
|
|
|
return clone;
|
|
},
|
|
|
|
_minBufferSize: 0
|
|
});
|
|
|
|
/**
|
|
* Abstract hasher template.
|
|
*
|
|
* @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
|
|
*/
|
|
C_lib.Hasher = BufferedBlockAlgorithm.extend({
|
|
/**
|
|
* Configuration options.
|
|
*/
|
|
cfg: Base.extend(),
|
|
|
|
/**
|
|
* Initializes a newly created hasher.
|
|
*
|
|
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
|
|
*
|
|
* @example
|
|
*
|
|
* var hasher = CryptoJS.algo.SHA256.create();
|
|
*/
|
|
init: function (cfg) {
|
|
// Apply config defaults
|
|
this.cfg = this.cfg.extend(cfg);
|
|
|
|
// Set initial values
|
|
this.reset();
|
|
},
|
|
|
|
/**
|
|
* Resets this hasher to its initial state.
|
|
*
|
|
* @example
|
|
*
|
|
* hasher.reset();
|
|
*/
|
|
reset: function () {
|
|
// Reset data buffer
|
|
BufferedBlockAlgorithm.reset.call(this);
|
|
|
|
// Perform concrete-hasher logic
|
|
this._doReset();
|
|
},
|
|
|
|
/**
|
|
* Updates this hasher with a message.
|
|
*
|
|
* @param {WordArray|string} messageUpdate The message to append.
|
|
*
|
|
* @return {Hasher} This hasher.
|
|
*
|
|
* @example
|
|
*
|
|
* hasher.update('message');
|
|
* hasher.update(wordArray);
|
|
*/
|
|
update: function (messageUpdate) {
|
|
// Append
|
|
this._append(messageUpdate);
|
|
|
|
// Update the hash
|
|
this._process();
|
|
|
|
// Chainable
|
|
return this;
|
|
},
|
|
|
|
/**
|
|
* Finalizes the hash computation.
|
|
* Note that the finalize operation is effectively a destructive, read-once operation.
|
|
*
|
|
* @param {WordArray|string} messageUpdate (Optional) A final message update.
|
|
*
|
|
* @return {WordArray} The hash.
|
|
*
|
|
* @example
|
|
*
|
|
* var hash = hasher.finalize();
|
|
* var hash = hasher.finalize('message');
|
|
* var hash = hasher.finalize(wordArray);
|
|
*/
|
|
finalize: function (messageUpdate) {
|
|
// Final message update
|
|
if (messageUpdate) {
|
|
this._append(messageUpdate);
|
|
}
|
|
|
|
// Perform concrete-hasher logic
|
|
var hash = this._doFinalize();
|
|
|
|
return hash;
|
|
},
|
|
|
|
blockSize: 512/32,
|
|
|
|
/**
|
|
* Creates a shortcut function to a hasher's object interface.
|
|
*
|
|
* @param {Hasher} hasher The hasher to create a helper for.
|
|
*
|
|
* @return {Function} The shortcut function.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
|
|
*/
|
|
_createHelper: function (hasher) {
|
|
return function (message, cfg) {
|
|
return new hasher.init(cfg).finalize(message);
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Creates a shortcut function to the HMAC's object interface.
|
|
*
|
|
* @param {Hasher} hasher The hasher to use in this HMAC helper.
|
|
*
|
|
* @return {Function} The shortcut function.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
|
|
*/
|
|
_createHmacHelper: function (hasher) {
|
|
return function (message, key) {
|
|
return new C_algo.HMAC.init(hasher, key).finalize(message);
|
|
};
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Algorithm namespace.
|
|
*/
|
|
var C_algo = C.algo = {};
|
|
|
|
return C;
|
|
}(Math));
|
|
|
|
|
|
return CryptoJS;
|
|
|
|
}));
|
|
} (core, core.exports));
|
|
return core.exports;
|
|
}
|
|
|
|
md5$1.exports;
|
|
|
|
(function (module, exports) {
|
|
(function (root, factory) {
|
|
{
|
|
// CommonJS
|
|
module.exports = factory(requireCore());
|
|
}
|
|
}(commonjsGlobal, function (CryptoJS) {
|
|
|
|
(function (Math) {
|
|
// Shortcuts
|
|
var C = CryptoJS;
|
|
var C_lib = C.lib;
|
|
var WordArray = C_lib.WordArray;
|
|
var Hasher = C_lib.Hasher;
|
|
var C_algo = C.algo;
|
|
|
|
// Constants table
|
|
var T = [];
|
|
|
|
// Compute constants
|
|
(function () {
|
|
for (var i = 0; i < 64; i++) {
|
|
T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
|
|
}
|
|
}());
|
|
|
|
/**
|
|
* MD5 hash algorithm.
|
|
*/
|
|
var MD5 = C_algo.MD5 = Hasher.extend({
|
|
_doReset: function () {
|
|
this._hash = new WordArray.init([
|
|
0x67452301, 0xefcdab89,
|
|
0x98badcfe, 0x10325476
|
|
]);
|
|
},
|
|
|
|
_doProcessBlock: function (M, offset) {
|
|
// Swap endian
|
|
for (var i = 0; i < 16; i++) {
|
|
// Shortcuts
|
|
var offset_i = offset + i;
|
|
var M_offset_i = M[offset_i];
|
|
|
|
M[offset_i] = (
|
|
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
|
|
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
|
|
);
|
|
}
|
|
|
|
// Shortcuts
|
|
var H = this._hash.words;
|
|
|
|
var M_offset_0 = M[offset + 0];
|
|
var M_offset_1 = M[offset + 1];
|
|
var M_offset_2 = M[offset + 2];
|
|
var M_offset_3 = M[offset + 3];
|
|
var M_offset_4 = M[offset + 4];
|
|
var M_offset_5 = M[offset + 5];
|
|
var M_offset_6 = M[offset + 6];
|
|
var M_offset_7 = M[offset + 7];
|
|
var M_offset_8 = M[offset + 8];
|
|
var M_offset_9 = M[offset + 9];
|
|
var M_offset_10 = M[offset + 10];
|
|
var M_offset_11 = M[offset + 11];
|
|
var M_offset_12 = M[offset + 12];
|
|
var M_offset_13 = M[offset + 13];
|
|
var M_offset_14 = M[offset + 14];
|
|
var M_offset_15 = M[offset + 15];
|
|
|
|
// Working variables
|
|
var a = H[0];
|
|
var b = H[1];
|
|
var c = H[2];
|
|
var d = H[3];
|
|
|
|
// Computation
|
|
a = FF(a, b, c, d, M_offset_0, 7, T[0]);
|
|
d = FF(d, a, b, c, M_offset_1, 12, T[1]);
|
|
c = FF(c, d, a, b, M_offset_2, 17, T[2]);
|
|
b = FF(b, c, d, a, M_offset_3, 22, T[3]);
|
|
a = FF(a, b, c, d, M_offset_4, 7, T[4]);
|
|
d = FF(d, a, b, c, M_offset_5, 12, T[5]);
|
|
c = FF(c, d, a, b, M_offset_6, 17, T[6]);
|
|
b = FF(b, c, d, a, M_offset_7, 22, T[7]);
|
|
a = FF(a, b, c, d, M_offset_8, 7, T[8]);
|
|
d = FF(d, a, b, c, M_offset_9, 12, T[9]);
|
|
c = FF(c, d, a, b, M_offset_10, 17, T[10]);
|
|
b = FF(b, c, d, a, M_offset_11, 22, T[11]);
|
|
a = FF(a, b, c, d, M_offset_12, 7, T[12]);
|
|
d = FF(d, a, b, c, M_offset_13, 12, T[13]);
|
|
c = FF(c, d, a, b, M_offset_14, 17, T[14]);
|
|
b = FF(b, c, d, a, M_offset_15, 22, T[15]);
|
|
|
|
a = GG(a, b, c, d, M_offset_1, 5, T[16]);
|
|
d = GG(d, a, b, c, M_offset_6, 9, T[17]);
|
|
c = GG(c, d, a, b, M_offset_11, 14, T[18]);
|
|
b = GG(b, c, d, a, M_offset_0, 20, T[19]);
|
|
a = GG(a, b, c, d, M_offset_5, 5, T[20]);
|
|
d = GG(d, a, b, c, M_offset_10, 9, T[21]);
|
|
c = GG(c, d, a, b, M_offset_15, 14, T[22]);
|
|
b = GG(b, c, d, a, M_offset_4, 20, T[23]);
|
|
a = GG(a, b, c, d, M_offset_9, 5, T[24]);
|
|
d = GG(d, a, b, c, M_offset_14, 9, T[25]);
|
|
c = GG(c, d, a, b, M_offset_3, 14, T[26]);
|
|
b = GG(b, c, d, a, M_offset_8, 20, T[27]);
|
|
a = GG(a, b, c, d, M_offset_13, 5, T[28]);
|
|
d = GG(d, a, b, c, M_offset_2, 9, T[29]);
|
|
c = GG(c, d, a, b, M_offset_7, 14, T[30]);
|
|
b = GG(b, c, d, a, M_offset_12, 20, T[31]);
|
|
|
|
a = HH(a, b, c, d, M_offset_5, 4, T[32]);
|
|
d = HH(d, a, b, c, M_offset_8, 11, T[33]);
|
|
c = HH(c, d, a, b, M_offset_11, 16, T[34]);
|
|
b = HH(b, c, d, a, M_offset_14, 23, T[35]);
|
|
a = HH(a, b, c, d, M_offset_1, 4, T[36]);
|
|
d = HH(d, a, b, c, M_offset_4, 11, T[37]);
|
|
c = HH(c, d, a, b, M_offset_7, 16, T[38]);
|
|
b = HH(b, c, d, a, M_offset_10, 23, T[39]);
|
|
a = HH(a, b, c, d, M_offset_13, 4, T[40]);
|
|
d = HH(d, a, b, c, M_offset_0, 11, T[41]);
|
|
c = HH(c, d, a, b, M_offset_3, 16, T[42]);
|
|
b = HH(b, c, d, a, M_offset_6, 23, T[43]);
|
|
a = HH(a, b, c, d, M_offset_9, 4, T[44]);
|
|
d = HH(d, a, b, c, M_offset_12, 11, T[45]);
|
|
c = HH(c, d, a, b, M_offset_15, 16, T[46]);
|
|
b = HH(b, c, d, a, M_offset_2, 23, T[47]);
|
|
|
|
a = II(a, b, c, d, M_offset_0, 6, T[48]);
|
|
d = II(d, a, b, c, M_offset_7, 10, T[49]);
|
|
c = II(c, d, a, b, M_offset_14, 15, T[50]);
|
|
b = II(b, c, d, a, M_offset_5, 21, T[51]);
|
|
a = II(a, b, c, d, M_offset_12, 6, T[52]);
|
|
d = II(d, a, b, c, M_offset_3, 10, T[53]);
|
|
c = II(c, d, a, b, M_offset_10, 15, T[54]);
|
|
b = II(b, c, d, a, M_offset_1, 21, T[55]);
|
|
a = II(a, b, c, d, M_offset_8, 6, T[56]);
|
|
d = II(d, a, b, c, M_offset_15, 10, T[57]);
|
|
c = II(c, d, a, b, M_offset_6, 15, T[58]);
|
|
b = II(b, c, d, a, M_offset_13, 21, T[59]);
|
|
a = II(a, b, c, d, M_offset_4, 6, T[60]);
|
|
d = II(d, a, b, c, M_offset_11, 10, T[61]);
|
|
c = II(c, d, a, b, M_offset_2, 15, T[62]);
|
|
b = II(b, c, d, a, M_offset_9, 21, T[63]);
|
|
|
|
// Intermediate hash value
|
|
H[0] = (H[0] + a) | 0;
|
|
H[1] = (H[1] + b) | 0;
|
|
H[2] = (H[2] + c) | 0;
|
|
H[3] = (H[3] + d) | 0;
|
|
},
|
|
|
|
_doFinalize: function () {
|
|
// Shortcuts
|
|
var data = this._data;
|
|
var dataWords = data.words;
|
|
|
|
var nBitsTotal = this._nDataBytes * 8;
|
|
var nBitsLeft = data.sigBytes * 8;
|
|
|
|
// Add padding
|
|
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
|
|
|
|
var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
|
|
var nBitsTotalL = nBitsTotal;
|
|
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
|
|
(((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
|
|
(((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
|
|
);
|
|
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
|
|
(((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
|
|
(((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
|
|
);
|
|
|
|
data.sigBytes = (dataWords.length + 1) * 4;
|
|
|
|
// Hash final blocks
|
|
this._process();
|
|
|
|
// Shortcuts
|
|
var hash = this._hash;
|
|
var H = hash.words;
|
|
|
|
// Swap endian
|
|
for (var i = 0; i < 4; i++) {
|
|
// Shortcut
|
|
var H_i = H[i];
|
|
|
|
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
|
|
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
|
|
}
|
|
|
|
// Return final computed hash
|
|
return hash;
|
|
},
|
|
|
|
clone: function () {
|
|
var clone = Hasher.clone.call(this);
|
|
clone._hash = this._hash.clone();
|
|
|
|
return clone;
|
|
}
|
|
});
|
|
|
|
function FF(a, b, c, d, x, s, t) {
|
|
var n = a + ((b & c) | (~b & d)) + x + t;
|
|
return ((n << s) | (n >>> (32 - s))) + b;
|
|
}
|
|
|
|
function GG(a, b, c, d, x, s, t) {
|
|
var n = a + ((b & d) | (c & ~d)) + x + t;
|
|
return ((n << s) | (n >>> (32 - s))) + b;
|
|
}
|
|
|
|
function HH(a, b, c, d, x, s, t) {
|
|
var n = a + (b ^ c ^ d) + x + t;
|
|
return ((n << s) | (n >>> (32 - s))) + b;
|
|
}
|
|
|
|
function II(a, b, c, d, x, s, t) {
|
|
var n = a + (c ^ (b | ~d)) + x + t;
|
|
return ((n << s) | (n >>> (32 - s))) + b;
|
|
}
|
|
|
|
/**
|
|
* Shortcut function to the hasher's object interface.
|
|
*
|
|
* @param {WordArray|string} message The message to hash.
|
|
*
|
|
* @return {WordArray} The hash.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var hash = CryptoJS.MD5('message');
|
|
* var hash = CryptoJS.MD5(wordArray);
|
|
*/
|
|
C.MD5 = Hasher._createHelper(MD5);
|
|
|
|
/**
|
|
* Shortcut function to the HMAC's object interface.
|
|
*
|
|
* @param {WordArray|string} message The message to hash.
|
|
* @param {WordArray|string} key The secret key.
|
|
*
|
|
* @return {WordArray} The HMAC.
|
|
*
|
|
* @static
|
|
*
|
|
* @example
|
|
*
|
|
* var hmac = CryptoJS.HmacMD5(message, key);
|
|
*/
|
|
C.HmacMD5 = Hasher._createHmacHelper(MD5);
|
|
}(Math));
|
|
|
|
|
|
return CryptoJS.MD5;
|
|
|
|
}));
|
|
} (md5$1, md5$1.exports));
|
|
|
|
var md5Exports = md5$1.exports;
|
|
var md5 = /*@__PURE__*/getDefaultExportFromCjs(md5Exports);
|
|
|
|
const APP_TITLE = "Local Images Plus 0.16.4";
|
|
//Option to enable debugging
|
|
let VERBOSE = false;
|
|
function setDebug(value = false) {
|
|
VERBOSE = value;
|
|
}
|
|
const SUPPORTED_OS = { "win": "win32", "unix": "linux,darwin,freebsd,openbsd" };
|
|
const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36';
|
|
const MD_SEARCH_PATTERN = [
|
|
//file link
|
|
/\!\[(?<anchor>(.{0}|(?!^file\:\/)+?))\]\((?<link>((file\:\/)[^\!]+?(\.{1}.{3,4}\) {0,1}|\)$|\)\n|\)])))/gm,
|
|
//hypertext link
|
|
///\!\[(?<anchor>(.{0}|[^\[]+?))\]\((?<link>((http(s){0,1}).+?(\) |\..{3,4}\)|\)$|\)\n|\)\]|\)\[)))/gm,
|
|
/\!\[(?<anchor>([^\]]*))\]\((?<link>((http(s){0,1}).+?(\) |\..{3,4}\)|\)$|\)\n|\)\]|\)\[)))/gm,
|
|
//Base64 encoded data
|
|
/\!\[[^\[](?<anchor>(.{0}|[^\[]+?))\]\((?<link>((data\:.+?base64\,).+?(\) |\..{3,4}\)|\)$|\)\n|\)\]|\)\[)))/gm,
|
|
/\!\[(?<anchor>(.{0}|[^\[]+?))\]\((?<link>((http(s){0,1}|(data\:.+?base64\,)).+?\)))/gm
|
|
];
|
|
const MD_LINK = /\http(s){0,1}.+?( {1}|\)\n)/g;
|
|
const ATT_SIZE_ACHOR = /(^(?<attdesc>.{1,})\|(?<attsize>[0-9]{2,4})$)|(?<attsize2>^[0-9]{2,4}$)/gm;
|
|
// Looks like timeouts in Obsidian API are set in milliseconds
|
|
const NOTICE_TIMEOUT = 5 * 1000;
|
|
const TIMEOUT_LIKE_INFINITY = 24 * 60 * 60 * 1000;
|
|
const FORBIDDEN_SYMBOLS_FILENAME_PATTERN = /\s+/g;
|
|
const DEFAULT_SETTINGS = {
|
|
processCreated: true,
|
|
ignoredExt: "cnt|php|htm|html",
|
|
processAll: true,
|
|
useCaptions: true,
|
|
pathInTags: "fullDirPath",
|
|
downUnknown: false,
|
|
saveAttE: "obsFolder",
|
|
realTimeUpdate: true,
|
|
filesizeLimit: 0,
|
|
tryCount: 2,
|
|
realTimeUpdateInterval: 5,
|
|
addNameOfFile: true,
|
|
showNotifications: true,
|
|
includeps: "md|canvas",
|
|
includepattern: "(?<md>.*\\.md)|(?<canvas>.*\\.canvas)",
|
|
mediaRootDir: "_resources/${notename}",
|
|
disAddCom: false,
|
|
useMD5ForNewAtt: true,
|
|
removeMediaFolder: true,
|
|
removeOrphansCompl: false,
|
|
PngToJpeg: false,
|
|
PngToJpegLocal: true,
|
|
JpegQuality: 80,
|
|
DoNotCreateObsFolder: false,
|
|
DateFormat: "YYYY MM DD",
|
|
ImgCompressionType: "image/jpeg",
|
|
ExcludedFoldersList: "",
|
|
ExcludedFoldersListRegexp: ""
|
|
};
|
|
|
|
const fs2 = require('fs').promises;
|
|
//import { TIMEOUT } from "dns";
|
|
//import fs from "fs";
|
|
/*
|
|
https://stackoverflow.com/a/48032528/1020973
|
|
It will be better to do it type-correct.
|
|
*/
|
|
function showBalloon(str, show = true, timeout = NOTICE_TIMEOUT) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (show) {
|
|
new obsidian.Notice(APP_TITLE + "\r\n" + str, timeout);
|
|
}
|
|
});
|
|
}
|
|
function displayError(error, file) {
|
|
if (file) {
|
|
showBalloon(`LocalImagesPlus: Error while handling file ${file.name}, ${error.toString()}`);
|
|
}
|
|
else {
|
|
showBalloon(error.toString());
|
|
}
|
|
logError(`LocalImagesPlus: error: ${error}`, false);
|
|
}
|
|
function logError(str, isObj = false) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (VERBOSE) {
|
|
console.log(APP_TITLE + ": ");
|
|
if (isObj) {
|
|
console.table(str);
|
|
}
|
|
else {
|
|
console.log(str);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function md5Sig(contentData = undefined) {
|
|
try {
|
|
var dec = new TextDecoder("utf-8");
|
|
const arrMid = Math.round(contentData.byteLength / 2);
|
|
const chunk = 15000;
|
|
const signature = md5([
|
|
contentData.slice(0, chunk),
|
|
contentData.slice(arrMid, arrMid + chunk),
|
|
contentData.slice(-chunk)
|
|
].map(x => dec.decode(x)).join()).toString();
|
|
return signature + "_MD5";
|
|
}
|
|
catch (e) {
|
|
logError("Cannot generate md5: " + e, false);
|
|
return null;
|
|
}
|
|
}
|
|
function replaceAsync(str, regex, asyncFn) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
logError("replaceAsync: \r\nstr: " + str + "\r\nregex: ");
|
|
logError(regex, true);
|
|
let errorflag = false;
|
|
const promises = [];
|
|
let dictPatt = [];
|
|
let link;
|
|
let anchor;
|
|
let replp;
|
|
let caption = "";
|
|
let filesArr = [];
|
|
let AttSize = "";
|
|
regex.forEach((element) => {
|
|
var _a;
|
|
logError("cur regex: " + element);
|
|
const matches = str.matchAll(element);
|
|
for (const match of matches) {
|
|
logError("match: " + match);
|
|
anchor = trimAny(match.groups.anchor, [")", "(", "]", "[", " "]);
|
|
const AttSizeMatch = anchor.matchAll(ATT_SIZE_ACHOR);
|
|
for (const match of AttSizeMatch) {
|
|
AttSize = (match.groups.attsize !== undefined) ? trimAny(match.groups.attsize, [")", "(", "]", "[", " "]) :
|
|
(match.groups.attsize2 !== undefined) ? trimAny(match.groups.attsize2, [")", "(", "]", "[", " "]) :
|
|
"";
|
|
}
|
|
link = ((_a = match.groups.link.match(MD_LINK)) !== null && _a !== void 0 ? _a : [match.groups.link])[0];
|
|
caption = trimAny((match.groups.link.match(MD_LINK) !== null ?
|
|
(match.groups.link.split(link).length > 1 ?
|
|
match.groups.link.split(link)[1] : "") :
|
|
""), [")", "]", "(", "[", " "]);
|
|
link = trimAny(link, [")", "(", "]", "[", " "]);
|
|
replp = trimAny(match[0], ["[", "(", "]"]);
|
|
logError("repl: " + replp +
|
|
"\r\nahc: " + anchor +
|
|
"\r\nlink: " + link +
|
|
"\r\ncaption: " + caption +
|
|
"\r\nAttSize: " + AttSize);
|
|
dictPatt[replp] = [anchor, link, caption, AttSize];
|
|
}
|
|
});
|
|
for (var key in dictPatt) {
|
|
const promise = asyncFn(key, dictPatt[key][0], dictPatt[key][1], dictPatt[key][2], dictPatt[key][3]);
|
|
logError(promise, true);
|
|
promises.push(promise);
|
|
}
|
|
const data = yield Promise.all(promises);
|
|
logError("Promises: ");
|
|
logError(data, true);
|
|
// return str.replace((reg: RegExp, str: String) => {
|
|
data.forEach((element) => {
|
|
if (element !== null) {
|
|
logError("el: " + element[0] + " el2: " + element[1] + element[2]);
|
|
str = str.replaceAll(element[0], element[1] + element[2]);
|
|
filesArr.push(element[1]);
|
|
}
|
|
else {
|
|
errorflag = true;
|
|
}
|
|
});
|
|
return [str, errorflag, filesArr];
|
|
// return str.replace( () => data.shift());
|
|
});
|
|
}
|
|
function isUrl(link) {
|
|
logError("IsUrl: " + link, false);
|
|
try {
|
|
return Boolean(new URL(link));
|
|
}
|
|
catch (_) {
|
|
return false;
|
|
}
|
|
}
|
|
function base64ToBuff(data) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
logError("base64ToBuff: \r\n", false);
|
|
try {
|
|
const BufferData = Buffer.from(data.split("base64,")[1], 'base64');
|
|
logError(BufferData);
|
|
return BufferData;
|
|
}
|
|
catch (e) {
|
|
logError("Cannot read base64: " + e, false);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
function readFromDiskB(file, count = undefined) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
const buffer = Buffer.alloc(count);
|
|
const fd = fs__default["default"].openSync(file, "r+");
|
|
fs__default["default"].readSync(fd, buffer, 0, buffer.length, 0);
|
|
logError(buffer);
|
|
fs__default["default"].closeSync(fd);
|
|
return buffer;
|
|
}
|
|
catch (e) {
|
|
logError("Cannot read the file: " + e, false);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
function readFromDisk(file) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
logError("readFromDisk: " + file, false);
|
|
try {
|
|
const data = yield fs2.readFile(file, null);
|
|
return Buffer.from(data);
|
|
}
|
|
catch (e) {
|
|
logError("Cannot read the file: " + e, false);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
function downloadImage(url) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
logError("Downloading: " + url, false);
|
|
const headers = {
|
|
'method': 'GET',
|
|
'User-Agent': USER_AGENT
|
|
};
|
|
try {
|
|
const res = yield obsidian.requestUrl({ url: url, headers });
|
|
logError(res, true);
|
|
return res.arrayBuffer;
|
|
}
|
|
catch (e) {
|
|
logError("Cannot download the file: " + e, false);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
function getFileExt(content, link) {
|
|
var _a;
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const fileExtByLink = path__default["default"].extname(link).replace("\.", "");
|
|
const fileExtByBuffer = (_a = (yield fileType_1.fromBuffer(content))) === null || _a === void 0 ? void 0 : _a.ext;
|
|
// if XML, probably it is SVG
|
|
if (fileExtByBuffer == "xml" || !fileExtByBuffer) {
|
|
const buffer = Buffer.from(content);
|
|
if (isSvg$1(buffer))
|
|
return "svg";
|
|
}
|
|
logError("fileExtByBuffer" + fileExtByBuffer);
|
|
if (fileExtByBuffer != undefined && fileExtByBuffer && fileExtByBuffer.length <= 5 && (fileExtByBuffer === null || fileExtByBuffer === void 0 ? void 0 : fileExtByBuffer.length) > 0) {
|
|
return fileExtByBuffer;
|
|
}
|
|
logError("fileExtByLink " + fileExtByLink);
|
|
if (fileExtByLink != undefined && fileExtByLink.length <= 5 && (fileExtByLink === null || fileExtByLink === void 0 ? void 0 : fileExtByLink.length) > 0) {
|
|
return fileExtByLink;
|
|
}
|
|
return "unknown";
|
|
});
|
|
}
|
|
//https://stackoverflow.com/questions/26156292/trim-specific-character-from-a-string
|
|
function trimAny(str, chars) {
|
|
var start = 0, end = str.length;
|
|
while (start < end && chars.indexOf(str[start]) >= 0)
|
|
++start;
|
|
while (end > start && chars.indexOf(str[end - 1]) >= 0)
|
|
--end;
|
|
return (start > 0 || end < str.length) ? str.substring(start, end) : str;
|
|
}
|
|
function cFileName(name) {
|
|
const cleanedName = name.replace(/(\)|\(|\"|\'|\#|\]|\[|\:|\>|\<|\*|\|)/g, " ");
|
|
return cleanedName;
|
|
}
|
|
function cleanFileName(name) {
|
|
const cleanedName = filenamify(name).replace(FORBIDDEN_SYMBOLS_FILENAME_PATTERN, "_");
|
|
return cleanedName;
|
|
}
|
|
function pathJoin(parts) {
|
|
const result = path__default["default"].join(...parts);
|
|
// it seems that obsidian do not understand paths with backslashes in Windows, so turn them into forward slashes
|
|
return result.replace(/\\/g, "/");
|
|
}
|
|
function normalizePath(path) {
|
|
return path.replace(/\\/g, "/");
|
|
}
|
|
function encObsURI(e) {
|
|
return e.replace(/[\\\x00\x08\x0B\x0C\x0E-\x1F ]/g, (function (e) {
|
|
return encodeURIComponent(e);
|
|
}));
|
|
}
|
|
/**
|
|
* https://github.com/mnaoumov/obsidian-dev-utils (modified)
|
|
* @param blob - The Blob object to convert.
|
|
* @param imgQuality - The quality of the image (0 to 1).
|
|
* @returns A promise that resolves to an ArrayBuffer.
|
|
*/
|
|
function blobToJpegArrayBuffer(blob, imgQuality, imgType = "image/jpeg") {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return new Promise((resolve) => {
|
|
const reader = new FileReader();
|
|
reader.onloadend = () => {
|
|
const image = new Image();
|
|
image.onload = () => {
|
|
const canvas = document.createElement('canvas');
|
|
const context = canvas.getContext('2d');
|
|
if (!context) {
|
|
throw new Error('Could not get 2D context.');
|
|
}
|
|
const imageWidth = image.width;
|
|
const imageHeight = image.height;
|
|
let data = '';
|
|
canvas.width = imageWidth;
|
|
canvas.height = imageHeight;
|
|
context.fillStyle = '#fff';
|
|
context.fillRect(0, 0, imageWidth, imageHeight);
|
|
context.save();
|
|
context.translate(imageWidth / 2, imageHeight / 2);
|
|
context.drawImage(image, 0, 0, imageWidth, imageHeight, -imageWidth / 2, -imageHeight / 2, imageWidth, imageHeight);
|
|
context.restore();
|
|
data = canvas.toDataURL(imgType, imgQuality);
|
|
const arrayBuffer = base64ToBuff(data);
|
|
resolve(arrayBuffer);
|
|
};
|
|
image.src = reader.result;
|
|
};
|
|
reader.readAsDataURL(blob);
|
|
});
|
|
});
|
|
}
|
|
|
|
// Generic options
|
|
class AnalyzerOptions {
|
|
constructor(heuristic_replimit) {
|
|
this.heuristic_replimit = heuristic_replimit;
|
|
}
|
|
}
|
|
|
|
// Abstract class
|
|
class Analyzer {
|
|
constructor(analyzerOptions) {
|
|
this.options = analyzerOptions;
|
|
}
|
|
|
|
// Subclasser must implement
|
|
// Return boolean
|
|
isVulnerable(regExp) {
|
|
return false;
|
|
}
|
|
|
|
// Subclass must implement
|
|
// Returns an AttackString or null
|
|
genAttackString(regExp) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var analyzer$2 = function(re, replimit) {
|
|
// Build an AST
|
|
let myRegExp = null;
|
|
let ast = null;
|
|
try {
|
|
// Construct a RegExp object
|
|
if (re instanceof RegExp) {
|
|
myRegExp = re;
|
|
} else if (typeof re === "string") {
|
|
myRegExp = new RegExp(re);
|
|
} else {
|
|
myRegExp = new RegExp(String(re));
|
|
}
|
|
|
|
// Build an AST
|
|
ast = regexpTree.parse(myRegExp);
|
|
} catch (err) {
|
|
// Invalid or unparseable input
|
|
return false;
|
|
}
|
|
|
|
let currentStarHeight = 0;
|
|
let maxObservedStarHeight = 0;
|
|
|
|
let repetitionCount = 0;
|
|
|
|
regexpTree.traverse(ast, {
|
|
Repetition: {
|
|
pre({ node }) {
|
|
repetitionCount++;
|
|
|
|
currentStarHeight++;
|
|
if (maxObservedStarHeight < currentStarHeight) {
|
|
maxObservedStarHeight = currentStarHeight;
|
|
}
|
|
},
|
|
|
|
post({ node }) {
|
|
currentStarHeight--;
|
|
}
|
|
}
|
|
});
|
|
|
|
return maxObservedStarHeight <= 1 && repetitionCount <= replimit;
|
|
};
|
|
|
|
analyzer$2 = {
|
|
"AnalyzerOptions": AnalyzerOptions,
|
|
"Analyzer": Analyzer,
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to translate `/./s` to `/[\0-\uFFFF]/`.
|
|
*/
|
|
|
|
var compatDotallSTransform = {
|
|
|
|
// Whether `u` flag present. In which case we transform to
|
|
// \u{10FFFF} instead of \uFFFF.
|
|
_hasUFlag: false,
|
|
|
|
// Only run this plugin if we have `s` flag.
|
|
shouldRun: function shouldRun(ast) {
|
|
var shouldRun = ast.flags.includes('s');
|
|
|
|
if (!shouldRun) {
|
|
return false;
|
|
}
|
|
|
|
// Strip the `s` flag.
|
|
ast.flags = ast.flags.replace('s', '');
|
|
|
|
// Whether we have also `u`.
|
|
this._hasUFlag = ast.flags.includes('u');
|
|
|
|
return true;
|
|
},
|
|
Char: function Char(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.kind !== 'meta' || node.value !== '.') {
|
|
return;
|
|
}
|
|
|
|
var toValue = '\\uFFFF';
|
|
var toSymbol = '\uFFFF';
|
|
|
|
if (this._hasUFlag) {
|
|
toValue = '\\u{10FFFF}';
|
|
toSymbol = '\uDBFF\uDFFF';
|
|
}
|
|
|
|
path.replace({
|
|
type: 'CharacterClass',
|
|
expressions: [{
|
|
type: 'ClassRange',
|
|
from: {
|
|
type: 'Char',
|
|
value: '\\0',
|
|
kind: 'decimal',
|
|
symbol: '\0'
|
|
},
|
|
to: {
|
|
type: 'Char',
|
|
value: toValue,
|
|
kind: 'unicode',
|
|
symbol: toSymbol
|
|
}
|
|
}]
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to translate `/(?<name>a)\k<name>/` to `/(a)\1/`.
|
|
*/
|
|
|
|
var compatNamedCapturingGroupsTransform = {
|
|
// To track the names of the groups, and return them
|
|
// in the transform result state.
|
|
//
|
|
// A map from name to number: {foo: 2, bar: 4}
|
|
_groupNames: {},
|
|
|
|
/**
|
|
* Initialises the trasnform.
|
|
*/
|
|
init: function init() {
|
|
this._groupNames = {};
|
|
},
|
|
|
|
|
|
/**
|
|
* Returns extra state, which eventually is returned to
|
|
*/
|
|
getExtra: function getExtra() {
|
|
return this._groupNames;
|
|
},
|
|
Group: function Group(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (!node.name) {
|
|
return;
|
|
}
|
|
|
|
// Record group name.
|
|
this._groupNames[node.name] = node.number;
|
|
|
|
delete node.name;
|
|
delete node.nameRaw;
|
|
},
|
|
Backreference: function Backreference(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.kind !== 'name') {
|
|
return;
|
|
}
|
|
|
|
node.kind = 'number';
|
|
node.reference = node.number;
|
|
delete node.referenceRaw;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to remove `x` flag `/foo/x` to `/foo/`.
|
|
*
|
|
* Note: other features of `x` flags (whitespace, comments) are
|
|
* already removed at parsing stage.
|
|
*/
|
|
|
|
var compatXFlagTransform = {
|
|
RegExp: function RegExp(_ref) {
|
|
var node = _ref.node;
|
|
|
|
if (node.flags.includes('x')) {
|
|
node.flags = node.flags.replace('x', '');
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var transforms$1 = {
|
|
// "dotAll" `s` flag
|
|
dotAll: compatDotallSTransform,
|
|
|
|
// Named capturing groups.
|
|
namedCapturingGroups: compatNamedCapturingGroupsTransform,
|
|
|
|
// `x` flag
|
|
xFlag: compatXFlagTransform
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* Helper `gen` function calls node type handler.
|
|
*/
|
|
|
|
function gen$1(node) {
|
|
return node ? generator$3[node.type](node) : '';
|
|
}
|
|
|
|
/**
|
|
* AST handler.
|
|
*/
|
|
var generator$3 = {
|
|
RegExp: function RegExp(node) {
|
|
return '/' + gen$1(node.body) + '/' + node.flags;
|
|
},
|
|
Alternative: function Alternative(node) {
|
|
return (node.expressions || []).map(gen$1).join('');
|
|
},
|
|
Disjunction: function Disjunction(node) {
|
|
return gen$1(node.left) + '|' + gen$1(node.right);
|
|
},
|
|
Group: function Group(node) {
|
|
var expression = gen$1(node.expression);
|
|
|
|
if (node.capturing) {
|
|
// A named group.
|
|
if (node.name) {
|
|
return '(?<' + (node.nameRaw || node.name) + '>' + expression + ')';
|
|
}
|
|
|
|
return '(' + expression + ')';
|
|
}
|
|
|
|
return '(?:' + expression + ')';
|
|
},
|
|
Backreference: function Backreference(node) {
|
|
switch (node.kind) {
|
|
case 'number':
|
|
return '\\' + node.reference;
|
|
case 'name':
|
|
return '\\k<' + (node.referenceRaw || node.reference) + '>';
|
|
default:
|
|
throw new TypeError('Unknown Backreference kind: ' + node.kind);
|
|
}
|
|
},
|
|
Assertion: function Assertion(node) {
|
|
switch (node.kind) {
|
|
case '^':
|
|
case '$':
|
|
case '\\b':
|
|
case '\\B':
|
|
return node.kind;
|
|
|
|
case 'Lookahead':
|
|
{
|
|
var assertion = gen$1(node.assertion);
|
|
|
|
if (node.negative) {
|
|
return '(?!' + assertion + ')';
|
|
}
|
|
|
|
return '(?=' + assertion + ')';
|
|
}
|
|
|
|
case 'Lookbehind':
|
|
{
|
|
var _assertion = gen$1(node.assertion);
|
|
|
|
if (node.negative) {
|
|
return '(?<!' + _assertion + ')';
|
|
}
|
|
|
|
return '(?<=' + _assertion + ')';
|
|
}
|
|
|
|
default:
|
|
throw new TypeError('Unknown Assertion kind: ' + node.kind);
|
|
}
|
|
},
|
|
CharacterClass: function CharacterClass(node) {
|
|
var expressions = node.expressions.map(gen$1).join('');
|
|
|
|
if (node.negative) {
|
|
return '[^' + expressions + ']';
|
|
}
|
|
|
|
return '[' + expressions + ']';
|
|
},
|
|
ClassRange: function ClassRange(node) {
|
|
return gen$1(node.from) + '-' + gen$1(node.to);
|
|
},
|
|
Repetition: function Repetition(node) {
|
|
return '' + gen$1(node.expression) + gen$1(node.quantifier);
|
|
},
|
|
Quantifier: function Quantifier(node) {
|
|
var quantifier = void 0;
|
|
var greedy = node.greedy ? '' : '?';
|
|
|
|
switch (node.kind) {
|
|
case '+':
|
|
case '?':
|
|
case '*':
|
|
quantifier = node.kind;
|
|
break;
|
|
case 'Range':
|
|
// Exact: {1}
|
|
if (node.from === node.to) {
|
|
quantifier = '{' + node.from + '}';
|
|
}
|
|
// Open: {1,}
|
|
else if (!node.to) {
|
|
quantifier = '{' + node.from + ',}';
|
|
}
|
|
// Closed: {1,3}
|
|
else {
|
|
quantifier = '{' + node.from + ',' + node.to + '}';
|
|
}
|
|
break;
|
|
default:
|
|
throw new TypeError('Unknown Quantifier kind: ' + node.kind);
|
|
}
|
|
|
|
return '' + quantifier + greedy;
|
|
},
|
|
Char: function Char(node) {
|
|
var value = node.value;
|
|
|
|
switch (node.kind) {
|
|
case 'simple':
|
|
{
|
|
if (node.escaped) {
|
|
return '\\' + value;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
case 'hex':
|
|
case 'unicode':
|
|
case 'oct':
|
|
case 'decimal':
|
|
case 'control':
|
|
case 'meta':
|
|
return value;
|
|
|
|
default:
|
|
throw new TypeError('Unknown Char kind: ' + node.kind);
|
|
}
|
|
},
|
|
UnicodeProperty: function UnicodeProperty(node) {
|
|
var escapeChar = node.negative ? 'P' : 'p';
|
|
var namePart = void 0;
|
|
|
|
if (!node.shorthand && !node.binary) {
|
|
namePart = node.name + '=';
|
|
} else {
|
|
namePart = '';
|
|
}
|
|
|
|
return '\\' + escapeChar + '{' + namePart + node.value + '}';
|
|
}
|
|
};
|
|
|
|
var generator_1 = {
|
|
/**
|
|
* Generates a regexp string from an AST.
|
|
*
|
|
* @param Object ast - an AST node
|
|
*/
|
|
generate: gen$1
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var NON_BINARY_PROP_NAMES_TO_ALIASES = {
|
|
General_Category: 'gc',
|
|
Script: 'sc',
|
|
Script_Extensions: 'scx'
|
|
};
|
|
|
|
var NON_BINARY_ALIASES_TO_PROP_NAMES = inverseMap(NON_BINARY_PROP_NAMES_TO_ALIASES);
|
|
|
|
var BINARY_PROP_NAMES_TO_ALIASES = {
|
|
ASCII: 'ASCII',
|
|
ASCII_Hex_Digit: 'AHex',
|
|
Alphabetic: 'Alpha',
|
|
Any: 'Any',
|
|
Assigned: 'Assigned',
|
|
Bidi_Control: 'Bidi_C',
|
|
Bidi_Mirrored: 'Bidi_M',
|
|
Case_Ignorable: 'CI',
|
|
Cased: 'Cased',
|
|
Changes_When_Casefolded: 'CWCF',
|
|
Changes_When_Casemapped: 'CWCM',
|
|
Changes_When_Lowercased: 'CWL',
|
|
Changes_When_NFKC_Casefolded: 'CWKCF',
|
|
Changes_When_Titlecased: 'CWT',
|
|
Changes_When_Uppercased: 'CWU',
|
|
Dash: 'Dash',
|
|
Default_Ignorable_Code_Point: 'DI',
|
|
Deprecated: 'Dep',
|
|
Diacritic: 'Dia',
|
|
Emoji: 'Emoji',
|
|
Emoji_Component: 'Emoji_Component',
|
|
Emoji_Modifier: 'Emoji_Modifier',
|
|
Emoji_Modifier_Base: 'Emoji_Modifier_Base',
|
|
Emoji_Presentation: 'Emoji_Presentation',
|
|
Extended_Pictographic: 'Extended_Pictographic',
|
|
Extender: 'Ext',
|
|
Grapheme_Base: 'Gr_Base',
|
|
Grapheme_Extend: 'Gr_Ext',
|
|
Hex_Digit: 'Hex',
|
|
IDS_Binary_Operator: 'IDSB',
|
|
IDS_Trinary_Operator: 'IDST',
|
|
ID_Continue: 'IDC',
|
|
ID_Start: 'IDS',
|
|
Ideographic: 'Ideo',
|
|
Join_Control: 'Join_C',
|
|
Logical_Order_Exception: 'LOE',
|
|
Lowercase: 'Lower',
|
|
Math: 'Math',
|
|
Noncharacter_Code_Point: 'NChar',
|
|
Pattern_Syntax: 'Pat_Syn',
|
|
Pattern_White_Space: 'Pat_WS',
|
|
Quotation_Mark: 'QMark',
|
|
Radical: 'Radical',
|
|
Regional_Indicator: 'RI',
|
|
Sentence_Terminal: 'STerm',
|
|
Soft_Dotted: 'SD',
|
|
Terminal_Punctuation: 'Term',
|
|
Unified_Ideograph: 'UIdeo',
|
|
Uppercase: 'Upper',
|
|
Variation_Selector: 'VS',
|
|
White_Space: 'space',
|
|
XID_Continue: 'XIDC',
|
|
XID_Start: 'XIDS'
|
|
};
|
|
|
|
var BINARY_ALIASES_TO_PROP_NAMES = inverseMap(BINARY_PROP_NAMES_TO_ALIASES);
|
|
|
|
var GENERAL_CATEGORY_VALUE_TO_ALIASES = {
|
|
Cased_Letter: 'LC',
|
|
Close_Punctuation: 'Pe',
|
|
Connector_Punctuation: 'Pc',
|
|
Control: ['Cc', 'cntrl'],
|
|
Currency_Symbol: 'Sc',
|
|
Dash_Punctuation: 'Pd',
|
|
Decimal_Number: ['Nd', 'digit'],
|
|
Enclosing_Mark: 'Me',
|
|
Final_Punctuation: 'Pf',
|
|
Format: 'Cf',
|
|
Initial_Punctuation: 'Pi',
|
|
Letter: 'L',
|
|
Letter_Number: 'Nl',
|
|
Line_Separator: 'Zl',
|
|
Lowercase_Letter: 'Ll',
|
|
Mark: ['M', 'Combining_Mark'],
|
|
Math_Symbol: 'Sm',
|
|
Modifier_Letter: 'Lm',
|
|
Modifier_Symbol: 'Sk',
|
|
Nonspacing_Mark: 'Mn',
|
|
Number: 'N',
|
|
Open_Punctuation: 'Ps',
|
|
Other: 'C',
|
|
Other_Letter: 'Lo',
|
|
Other_Number: 'No',
|
|
Other_Punctuation: 'Po',
|
|
Other_Symbol: 'So',
|
|
Paragraph_Separator: 'Zp',
|
|
Private_Use: 'Co',
|
|
Punctuation: ['P', 'punct'],
|
|
Separator: 'Z',
|
|
Space_Separator: 'Zs',
|
|
Spacing_Mark: 'Mc',
|
|
Surrogate: 'Cs',
|
|
Symbol: 'S',
|
|
Titlecase_Letter: 'Lt',
|
|
Unassigned: 'Cn',
|
|
Uppercase_Letter: 'Lu'
|
|
};
|
|
|
|
var GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES = inverseMap(GENERAL_CATEGORY_VALUE_TO_ALIASES);
|
|
|
|
var SCRIPT_VALUE_TO_ALIASES = {
|
|
Adlam: 'Adlm',
|
|
Ahom: 'Ahom',
|
|
Anatolian_Hieroglyphs: 'Hluw',
|
|
Arabic: 'Arab',
|
|
Armenian: 'Armn',
|
|
Avestan: 'Avst',
|
|
Balinese: 'Bali',
|
|
Bamum: 'Bamu',
|
|
Bassa_Vah: 'Bass',
|
|
Batak: 'Batk',
|
|
Bengali: 'Beng',
|
|
Bhaiksuki: 'Bhks',
|
|
Bopomofo: 'Bopo',
|
|
Brahmi: 'Brah',
|
|
Braille: 'Brai',
|
|
Buginese: 'Bugi',
|
|
Buhid: 'Buhd',
|
|
Canadian_Aboriginal: 'Cans',
|
|
Carian: 'Cari',
|
|
Caucasian_Albanian: 'Aghb',
|
|
Chakma: 'Cakm',
|
|
Cham: 'Cham',
|
|
Cherokee: 'Cher',
|
|
Common: 'Zyyy',
|
|
Coptic: ['Copt', 'Qaac'],
|
|
Cuneiform: 'Xsux',
|
|
Cypriot: 'Cprt',
|
|
Cyrillic: 'Cyrl',
|
|
Deseret: 'Dsrt',
|
|
Devanagari: 'Deva',
|
|
Dogra: 'Dogr',
|
|
Duployan: 'Dupl',
|
|
Egyptian_Hieroglyphs: 'Egyp',
|
|
Elbasan: 'Elba',
|
|
Ethiopic: 'Ethi',
|
|
Georgian: 'Geor',
|
|
Glagolitic: 'Glag',
|
|
Gothic: 'Goth',
|
|
Grantha: 'Gran',
|
|
Greek: 'Grek',
|
|
Gujarati: 'Gujr',
|
|
Gunjala_Gondi: 'Gong',
|
|
Gurmukhi: 'Guru',
|
|
Han: 'Hani',
|
|
Hangul: 'Hang',
|
|
Hanifi_Rohingya: 'Rohg',
|
|
Hanunoo: 'Hano',
|
|
Hatran: 'Hatr',
|
|
Hebrew: 'Hebr',
|
|
Hiragana: 'Hira',
|
|
Imperial_Aramaic: 'Armi',
|
|
Inherited: ['Zinh', 'Qaai'],
|
|
Inscriptional_Pahlavi: 'Phli',
|
|
Inscriptional_Parthian: 'Prti',
|
|
Javanese: 'Java',
|
|
Kaithi: 'Kthi',
|
|
Kannada: 'Knda',
|
|
Katakana: 'Kana',
|
|
Kayah_Li: 'Kali',
|
|
Kharoshthi: 'Khar',
|
|
Khmer: 'Khmr',
|
|
Khojki: 'Khoj',
|
|
Khudawadi: 'Sind',
|
|
Lao: 'Laoo',
|
|
Latin: 'Latn',
|
|
Lepcha: 'Lepc',
|
|
Limbu: 'Limb',
|
|
Linear_A: 'Lina',
|
|
Linear_B: 'Linb',
|
|
Lisu: 'Lisu',
|
|
Lycian: 'Lyci',
|
|
Lydian: 'Lydi',
|
|
Mahajani: 'Mahj',
|
|
Makasar: 'Maka',
|
|
Malayalam: 'Mlym',
|
|
Mandaic: 'Mand',
|
|
Manichaean: 'Mani',
|
|
Marchen: 'Marc',
|
|
Medefaidrin: 'Medf',
|
|
Masaram_Gondi: 'Gonm',
|
|
Meetei_Mayek: 'Mtei',
|
|
Mende_Kikakui: 'Mend',
|
|
Meroitic_Cursive: 'Merc',
|
|
Meroitic_Hieroglyphs: 'Mero',
|
|
Miao: 'Plrd',
|
|
Modi: 'Modi',
|
|
Mongolian: 'Mong',
|
|
Mro: 'Mroo',
|
|
Multani: 'Mult',
|
|
Myanmar: 'Mymr',
|
|
Nabataean: 'Nbat',
|
|
New_Tai_Lue: 'Talu',
|
|
Newa: 'Newa',
|
|
Nko: 'Nkoo',
|
|
Nushu: 'Nshu',
|
|
Ogham: 'Ogam',
|
|
Ol_Chiki: 'Olck',
|
|
Old_Hungarian: 'Hung',
|
|
Old_Italic: 'Ital',
|
|
Old_North_Arabian: 'Narb',
|
|
Old_Permic: 'Perm',
|
|
Old_Persian: 'Xpeo',
|
|
Old_Sogdian: 'Sogo',
|
|
Old_South_Arabian: 'Sarb',
|
|
Old_Turkic: 'Orkh',
|
|
Oriya: 'Orya',
|
|
Osage: 'Osge',
|
|
Osmanya: 'Osma',
|
|
Pahawh_Hmong: 'Hmng',
|
|
Palmyrene: 'Palm',
|
|
Pau_Cin_Hau: 'Pauc',
|
|
Phags_Pa: 'Phag',
|
|
Phoenician: 'Phnx',
|
|
Psalter_Pahlavi: 'Phlp',
|
|
Rejang: 'Rjng',
|
|
Runic: 'Runr',
|
|
Samaritan: 'Samr',
|
|
Saurashtra: 'Saur',
|
|
Sharada: 'Shrd',
|
|
Shavian: 'Shaw',
|
|
Siddham: 'Sidd',
|
|
SignWriting: 'Sgnw',
|
|
Sinhala: 'Sinh',
|
|
Sogdian: 'Sogd',
|
|
Sora_Sompeng: 'Sora',
|
|
Soyombo: 'Soyo',
|
|
Sundanese: 'Sund',
|
|
Syloti_Nagri: 'Sylo',
|
|
Syriac: 'Syrc',
|
|
Tagalog: 'Tglg',
|
|
Tagbanwa: 'Tagb',
|
|
Tai_Le: 'Tale',
|
|
Tai_Tham: 'Lana',
|
|
Tai_Viet: 'Tavt',
|
|
Takri: 'Takr',
|
|
Tamil: 'Taml',
|
|
Tangut: 'Tang',
|
|
Telugu: 'Telu',
|
|
Thaana: 'Thaa',
|
|
Thai: 'Thai',
|
|
Tibetan: 'Tibt',
|
|
Tifinagh: 'Tfng',
|
|
Tirhuta: 'Tirh',
|
|
Ugaritic: 'Ugar',
|
|
Vai: 'Vaii',
|
|
Warang_Citi: 'Wara',
|
|
Yi: 'Yiii',
|
|
Zanabazar_Square: 'Zanb'
|
|
};
|
|
|
|
var SCRIPT_VALUE_ALIASES_TO_VALUE = inverseMap(SCRIPT_VALUE_TO_ALIASES);
|
|
|
|
function inverseMap(data) {
|
|
var inverse = {};
|
|
|
|
for (var name in data) {
|
|
if (!data.hasOwnProperty(name)) {
|
|
continue;
|
|
}
|
|
var value = data[name];
|
|
if (Array.isArray(value)) {
|
|
for (var i = 0; i < value.length; i++) {
|
|
inverse[value[i]] = name;
|
|
}
|
|
} else {
|
|
inverse[value] = name;
|
|
}
|
|
}
|
|
|
|
return inverse;
|
|
}
|
|
|
|
function isValidName(name) {
|
|
return NON_BINARY_PROP_NAMES_TO_ALIASES.hasOwnProperty(name) || NON_BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name) || BINARY_PROP_NAMES_TO_ALIASES.hasOwnProperty(name) || BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name);
|
|
}
|
|
|
|
function isValidValue(name, value) {
|
|
if (isGeneralCategoryName(name)) {
|
|
return isGeneralCategoryValue(value);
|
|
}
|
|
|
|
if (isScriptCategoryName(name)) {
|
|
return isScriptCategoryValue(value);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function isAlias(name) {
|
|
return NON_BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name) || BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name);
|
|
}
|
|
|
|
function isGeneralCategoryName(name) {
|
|
return name === 'General_Category' || name == 'gc';
|
|
}
|
|
|
|
function isScriptCategoryName(name) {
|
|
return name === 'Script' || name === 'Script_Extensions' || name === 'sc' || name === 'scx';
|
|
}
|
|
|
|
function isGeneralCategoryValue(value) {
|
|
return GENERAL_CATEGORY_VALUE_TO_ALIASES.hasOwnProperty(value) || GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES.hasOwnProperty(value);
|
|
}
|
|
|
|
function isScriptCategoryValue(value) {
|
|
return SCRIPT_VALUE_TO_ALIASES.hasOwnProperty(value) || SCRIPT_VALUE_ALIASES_TO_VALUE.hasOwnProperty(value);
|
|
}
|
|
|
|
function isBinaryPropertyName(name) {
|
|
return BINARY_PROP_NAMES_TO_ALIASES.hasOwnProperty(name) || BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name);
|
|
}
|
|
|
|
function getCanonicalName(name) {
|
|
if (NON_BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name)) {
|
|
return NON_BINARY_ALIASES_TO_PROP_NAMES[name];
|
|
}
|
|
|
|
if (BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(name)) {
|
|
return BINARY_ALIASES_TO_PROP_NAMES[name];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function getCanonicalValue(value) {
|
|
if (GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES.hasOwnProperty(value)) {
|
|
return GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES[value];
|
|
}
|
|
|
|
if (SCRIPT_VALUE_ALIASES_TO_VALUE.hasOwnProperty(value)) {
|
|
return SCRIPT_VALUE_ALIASES_TO_VALUE[value];
|
|
}
|
|
|
|
if (BINARY_ALIASES_TO_PROP_NAMES.hasOwnProperty(value)) {
|
|
return BINARY_ALIASES_TO_PROP_NAMES[value];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
var parserUnicodeProperties = {
|
|
isAlias: isAlias,
|
|
isValidName: isValidName,
|
|
isValidValue: isValidValue,
|
|
isGeneralCategoryValue: isGeneralCategoryValue,
|
|
isScriptCategoryValue: isScriptCategoryValue,
|
|
isBinaryPropertyName: isBinaryPropertyName,
|
|
getCanonicalName: getCanonicalName,
|
|
getCanonicalValue: getCanonicalValue,
|
|
|
|
NON_BINARY_PROP_NAMES_TO_ALIASES: NON_BINARY_PROP_NAMES_TO_ALIASES,
|
|
NON_BINARY_ALIASES_TO_PROP_NAMES: NON_BINARY_ALIASES_TO_PROP_NAMES,
|
|
|
|
BINARY_PROP_NAMES_TO_ALIASES: BINARY_PROP_NAMES_TO_ALIASES,
|
|
BINARY_ALIASES_TO_PROP_NAMES: BINARY_ALIASES_TO_PROP_NAMES,
|
|
|
|
GENERAL_CATEGORY_VALUE_TO_ALIASES: GENERAL_CATEGORY_VALUE_TO_ALIASES,
|
|
GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES: GENERAL_CATEGORY_VALUE_ALIASES_TO_VALUES,
|
|
|
|
SCRIPT_VALUE_TO_ALIASES: SCRIPT_VALUE_TO_ALIASES,
|
|
SCRIPT_VALUE_ALIASES_TO_VALUE: SCRIPT_VALUE_ALIASES_TO_VALUE
|
|
};
|
|
|
|
/**
|
|
* LR parser generated by the Syntax tool.
|
|
*
|
|
* https://www.npmjs.com/package/syntax-cli
|
|
*
|
|
* npm install -g syntax-cli
|
|
*
|
|
* syntax-cli --help
|
|
*
|
|
* To regenerate run:
|
|
*
|
|
* syntax-cli \
|
|
* --grammar ~/path-to-grammar-file \
|
|
* --mode <parsing-mode> \
|
|
* --output ~/path-to-output-parser-file.js
|
|
*/
|
|
|
|
/**
|
|
* Matched token text.
|
|
*/
|
|
|
|
var _slicedToArray$2 = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
function _toConsumableArray$8(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var yytext = void 0;
|
|
|
|
/**
|
|
* Storage object.
|
|
*/
|
|
var yy = {};
|
|
|
|
/**
|
|
* Result of semantic action.
|
|
*/
|
|
var __ = void 0;
|
|
|
|
/**
|
|
* Result location object.
|
|
*/
|
|
var __loc = void 0;
|
|
|
|
function yyloc(start, end) {
|
|
if (!yy.options.captureLocations) {
|
|
return null;
|
|
}
|
|
|
|
// Epsilon doesn't produce location.
|
|
if (!start || !end) {
|
|
return start || end;
|
|
}
|
|
|
|
return {
|
|
startOffset: start.startOffset,
|
|
endOffset: end.endOffset,
|
|
startLine: start.startLine,
|
|
endLine: end.endLine,
|
|
startColumn: start.startColumn,
|
|
endColumn: end.endColumn
|
|
};
|
|
}
|
|
|
|
var EOF = '$';
|
|
|
|
/**
|
|
* List of productions (generated by Syntax tool).
|
|
*/
|
|
var productions = [[-1, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [0, 4, function (_1, _2, _3, _4, _1loc, _2loc, _3loc, _4loc) {
|
|
__loc = yyloc(_1loc, _4loc);
|
|
__ = Node({
|
|
type: 'RegExp',
|
|
body: _2,
|
|
flags: checkFlags(_4)
|
|
}, loc(_1loc, _4loc || _3loc));
|
|
}], [1, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [1, 0, function () {
|
|
__loc = null;__ = '';
|
|
}], [2, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [2, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);__ = _1 + _2;
|
|
}], [3, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [4, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [4, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
// Location for empty disjunction: /|/
|
|
var _loc = null;
|
|
|
|
if (_2loc) {
|
|
_loc = loc(_1loc || _2loc, _3loc || _2loc);
|
|
}
|
|
__ = Node({
|
|
type: 'Disjunction',
|
|
left: _1,
|
|
right: _3
|
|
}, _loc);
|
|
}], [5, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
if (_1.length === 0) {
|
|
__ = null;
|
|
return;
|
|
}
|
|
|
|
if (_1.length === 1) {
|
|
__ = Node(_1[0], __loc);
|
|
} else {
|
|
__ = Node({
|
|
type: 'Alternative',
|
|
expressions: _1
|
|
}, __loc);
|
|
}
|
|
}], [6, 0, function () {
|
|
__loc = null;__ = [];
|
|
}], [6, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);__ = _1.concat(_2);
|
|
}], [7, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Node(Object.assign({ type: 'Assertion' }, _1), __loc);
|
|
}], [7, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);
|
|
__ = _1;
|
|
|
|
if (_2) {
|
|
__ = Node({
|
|
type: 'Repetition',
|
|
expression: _1,
|
|
quantifier: _2
|
|
}, __loc);
|
|
}
|
|
}], [8, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = { kind: '^' };
|
|
}], [8, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = { kind: '$' };
|
|
}], [8, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = { kind: '\\b' };
|
|
}], [8, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = { kind: '\\B' };
|
|
}], [8, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = {
|
|
kind: 'Lookahead',
|
|
assertion: _2
|
|
};
|
|
}], [8, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = {
|
|
kind: 'Lookahead',
|
|
negative: true,
|
|
assertion: _2
|
|
};
|
|
}], [8, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = {
|
|
kind: 'Lookbehind',
|
|
assertion: _2
|
|
};
|
|
}], [8, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = {
|
|
kind: 'Lookbehind',
|
|
negative: true,
|
|
assertion: _2
|
|
};
|
|
}], [9, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [9, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [9, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'simple', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1.slice(1), 'simple', __loc);__.escaped = true;
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'unicode', __loc);__.isSurrogatePair = true;
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'unicode', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = UnicodeProperty(_1, __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'control', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'hex', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'oct', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = GroupRefOrDecChar(_1, __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'meta', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'meta', __loc);
|
|
}], [10, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = NamedGroupRefOrChars(_1, _1loc);
|
|
}], [11, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [11, 0], [12, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [12, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);
|
|
_1.greedy = false;
|
|
__ = _1;
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: _1,
|
|
greedy: true
|
|
}, __loc);
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: _1,
|
|
greedy: true
|
|
}, __loc);
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: _1,
|
|
greedy: true
|
|
}, __loc);
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
var range = getRange(_1);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: 'Range',
|
|
from: range[0],
|
|
to: range[0],
|
|
greedy: true
|
|
}, __loc);
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: 'Range',
|
|
from: getRange(_1)[0],
|
|
greedy: true
|
|
}, __loc);
|
|
}], [13, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);
|
|
var range = getRange(_1);
|
|
__ = Node({
|
|
type: 'Quantifier',
|
|
kind: 'Range',
|
|
from: range[0],
|
|
to: range[1],
|
|
greedy: true
|
|
}, __loc);
|
|
}], [14, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [14, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [15, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
var nameRaw = String(_1);
|
|
var name = decodeUnicodeGroupName(nameRaw);
|
|
if (!yy.options.allowGroupNameDuplicates && namedGroups.hasOwnProperty(name)) {
|
|
throw new SyntaxError('Duplicate of the named group "' + name + '".');
|
|
}
|
|
|
|
namedGroups[name] = _1.groupNumber;
|
|
|
|
__ = Node({
|
|
type: 'Group',
|
|
capturing: true,
|
|
name: name,
|
|
nameRaw: nameRaw,
|
|
number: _1.groupNumber,
|
|
expression: _2
|
|
}, __loc);
|
|
}], [15, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = Node({
|
|
type: 'Group',
|
|
capturing: true,
|
|
number: _1.groupNumber,
|
|
expression: _2
|
|
}, __loc);
|
|
}], [16, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = Node({
|
|
type: 'Group',
|
|
capturing: false,
|
|
expression: _2
|
|
}, __loc);
|
|
}], [17, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = Node({
|
|
type: 'CharacterClass',
|
|
negative: true,
|
|
expressions: _2
|
|
}, __loc);
|
|
}], [17, 3, function (_1, _2, _3, _1loc, _2loc, _3loc) {
|
|
__loc = yyloc(_1loc, _3loc);
|
|
__ = Node({
|
|
type: 'CharacterClass',
|
|
expressions: _2
|
|
}, __loc);
|
|
}], [18, 0, function () {
|
|
__loc = null;__ = [];
|
|
}], [18, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [19, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = [_1];
|
|
}], [19, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);__ = [_1].concat(_2);
|
|
}], [19, 4, function (_1, _2, _3, _4, _1loc, _2loc, _3loc, _4loc) {
|
|
__loc = yyloc(_1loc, _4loc);
|
|
checkClassRange(_1, _3);
|
|
|
|
__ = [Node({
|
|
type: 'ClassRange',
|
|
from: _1,
|
|
to: _3
|
|
}, loc(_1loc, _3loc))];
|
|
|
|
if (_4) {
|
|
__ = __.concat(_4);
|
|
}
|
|
}], [20, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [20, 2, function (_1, _2, _1loc, _2loc) {
|
|
__loc = yyloc(_1loc, _2loc);__ = [_1].concat(_2);
|
|
}], [20, 4, function (_1, _2, _3, _4, _1loc, _2loc, _3loc, _4loc) {
|
|
__loc = yyloc(_1loc, _4loc);
|
|
checkClassRange(_1, _3);
|
|
|
|
__ = [Node({
|
|
type: 'ClassRange',
|
|
from: _1,
|
|
to: _3
|
|
}, loc(_1loc, _3loc))];
|
|
|
|
if (_4) {
|
|
__ = __.concat(_4);
|
|
}
|
|
}], [21, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'simple', __loc);
|
|
}], [21, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [22, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = _1;
|
|
}], [22, 1, function (_1, _1loc) {
|
|
__loc = yyloc(_1loc, _1loc);__ = Char(_1, 'meta', __loc);
|
|
}]];
|
|
|
|
/**
|
|
* Encoded tokens map.
|
|
*/
|
|
var tokens = { "SLASH": "23", "CHAR": "24", "BAR": "25", "BOS": "26", "EOS": "27", "ESC_b": "28", "ESC_B": "29", "POS_LA_ASSERT": "30", "R_PAREN": "31", "NEG_LA_ASSERT": "32", "POS_LB_ASSERT": "33", "NEG_LB_ASSERT": "34", "ESC_CHAR": "35", "U_CODE_SURROGATE": "36", "U_CODE": "37", "U_PROP_VALUE_EXP": "38", "CTRL_CH": "39", "HEX_CODE": "40", "OCT_CODE": "41", "DEC_CODE": "42", "META_CHAR": "43", "ANY": "44", "NAMED_GROUP_REF": "45", "Q_MARK": "46", "STAR": "47", "PLUS": "48", "RANGE_EXACT": "49", "RANGE_OPEN": "50", "RANGE_CLOSED": "51", "NAMED_CAPTURE_GROUP": "52", "L_PAREN": "53", "NON_CAPTURE_GROUP": "54", "NEG_CLASS": "55", "R_BRACKET": "56", "L_BRACKET": "57", "DASH": "58", "$": "59" };
|
|
|
|
/**
|
|
* Parsing table (generated by Syntax tool).
|
|
*/
|
|
var table = [{ "0": 1, "23": "s2" }, { "59": "acc" }, { "3": 3, "4": 4, "5": 5, "6": 6, "23": "r10", "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "23": "s7" }, { "23": "r6", "25": "s12" }, { "23": "r7", "25": "r7", "31": "r7" }, { "7": 14, "8": 15, "9": 16, "10": 25, "14": 27, "15": 42, "16": 43, "17": 26, "23": "r9", "24": "s28", "25": "r9", "26": "s17", "27": "s18", "28": "s19", "29": "s20", "30": "s21", "31": "r9", "32": "s22", "33": "s23", "34": "s24", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "52": "s44", "53": "s45", "54": "s46", "55": "s40", "57": "s41" }, { "1": 8, "2": 9, "24": "s10", "59": "r3" }, { "59": "r1" }, { "24": "s11", "59": "r2" }, { "24": "r4", "59": "r4" }, { "24": "r5", "59": "r5" }, { "5": 13, "6": 6, "23": "r10", "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "23": "r8", "25": "r8", "31": "r8" }, { "23": "r11", "24": "r11", "25": "r11", "26": "r11", "27": "r11", "28": "r11", "29": "r11", "30": "r11", "31": "r11", "32": "r11", "33": "r11", "34": "r11", "35": "r11", "36": "r11", "37": "r11", "38": "r11", "39": "r11", "40": "r11", "41": "r11", "42": "r11", "43": "r11", "44": "r11", "45": "r11", "52": "r11", "53": "r11", "54": "r11", "55": "r11", "57": "r11" }, { "23": "r12", "24": "r12", "25": "r12", "26": "r12", "27": "r12", "28": "r12", "29": "r12", "30": "r12", "31": "r12", "32": "r12", "33": "r12", "34": "r12", "35": "r12", "36": "r12", "37": "r12", "38": "r12", "39": "r12", "40": "r12", "41": "r12", "42": "r12", "43": "r12", "44": "r12", "45": "r12", "52": "r12", "53": "r12", "54": "r12", "55": "r12", "57": "r12" }, { "11": 47, "12": 48, "13": 49, "23": "r38", "24": "r38", "25": "r38", "26": "r38", "27": "r38", "28": "r38", "29": "r38", "30": "r38", "31": "r38", "32": "r38", "33": "r38", "34": "r38", "35": "r38", "36": "r38", "37": "r38", "38": "r38", "39": "r38", "40": "r38", "41": "r38", "42": "r38", "43": "r38", "44": "r38", "45": "r38", "46": "s52", "47": "s50", "48": "s51", "49": "s53", "50": "s54", "51": "s55", "52": "r38", "53": "r38", "54": "r38", "55": "r38", "57": "r38" }, { "23": "r14", "24": "r14", "25": "r14", "26": "r14", "27": "r14", "28": "r14", "29": "r14", "30": "r14", "31": "r14", "32": "r14", "33": "r14", "34": "r14", "35": "r14", "36": "r14", "37": "r14", "38": "r14", "39": "r14", "40": "r14", "41": "r14", "42": "r14", "43": "r14", "44": "r14", "45": "r14", "52": "r14", "53": "r14", "54": "r14", "55": "r14", "57": "r14" }, { "23": "r15", "24": "r15", "25": "r15", "26": "r15", "27": "r15", "28": "r15", "29": "r15", "30": "r15", "31": "r15", "32": "r15", "33": "r15", "34": "r15", "35": "r15", "36": "r15", "37": "r15", "38": "r15", "39": "r15", "40": "r15", "41": "r15", "42": "r15", "43": "r15", "44": "r15", "45": "r15", "52": "r15", "53": "r15", "54": "r15", "55": "r15", "57": "r15" }, { "23": "r16", "24": "r16", "25": "r16", "26": "r16", "27": "r16", "28": "r16", "29": "r16", "30": "r16", "31": "r16", "32": "r16", "33": "r16", "34": "r16", "35": "r16", "36": "r16", "37": "r16", "38": "r16", "39": "r16", "40": "r16", "41": "r16", "42": "r16", "43": "r16", "44": "r16", "45": "r16", "52": "r16", "53": "r16", "54": "r16", "55": "r16", "57": "r16" }, { "23": "r17", "24": "r17", "25": "r17", "26": "r17", "27": "r17", "28": "r17", "29": "r17", "30": "r17", "31": "r17", "32": "r17", "33": "r17", "34": "r17", "35": "r17", "36": "r17", "37": "r17", "38": "r17", "39": "r17", "40": "r17", "41": "r17", "42": "r17", "43": "r17", "44": "r17", "45": "r17", "52": "r17", "53": "r17", "54": "r17", "55": "r17", "57": "r17" }, { "4": 57, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "4": 59, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "4": 61, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "4": 63, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "23": "r22", "24": "r22", "25": "r22", "26": "r22", "27": "r22", "28": "r22", "29": "r22", "30": "r22", "31": "r22", "32": "r22", "33": "r22", "34": "r22", "35": "r22", "36": "r22", "37": "r22", "38": "r22", "39": "r22", "40": "r22", "41": "r22", "42": "r22", "43": "r22", "44": "r22", "45": "r22", "46": "r22", "47": "r22", "48": "r22", "49": "r22", "50": "r22", "51": "r22", "52": "r22", "53": "r22", "54": "r22", "55": "r22", "57": "r22" }, { "23": "r23", "24": "r23", "25": "r23", "26": "r23", "27": "r23", "28": "r23", "29": "r23", "30": "r23", "31": "r23", "32": "r23", "33": "r23", "34": "r23", "35": "r23", "36": "r23", "37": "r23", "38": "r23", "39": "r23", "40": "r23", "41": "r23", "42": "r23", "43": "r23", "44": "r23", "45": "r23", "46": "r23", "47": "r23", "48": "r23", "49": "r23", "50": "r23", "51": "r23", "52": "r23", "53": "r23", "54": "r23", "55": "r23", "57": "r23" }, { "23": "r24", "24": "r24", "25": "r24", "26": "r24", "27": "r24", "28": "r24", "29": "r24", "30": "r24", "31": "r24", "32": "r24", "33": "r24", "34": "r24", "35": "r24", "36": "r24", "37": "r24", "38": "r24", "39": "r24", "40": "r24", "41": "r24", "42": "r24", "43": "r24", "44": "r24", "45": "r24", "46": "r24", "47": "r24", "48": "r24", "49": "r24", "50": "r24", "51": "r24", "52": "r24", "53": "r24", "54": "r24", "55": "r24", "57": "r24" }, { "23": "r25", "24": "r25", "25": "r25", "26": "r25", "27": "r25", "28": "r25", "29": "r25", "30": "r25", "31": "r25", "32": "r25", "33": "r25", "34": "r25", "35": "r25", "36": "r25", "37": "r25", "38": "r25", "39": "r25", "40": "r25", "41": "r25", "42": "r25", "43": "r25", "44": "r25", "45": "r25", "46": "r25", "47": "r25", "48": "r25", "49": "r25", "50": "r25", "51": "r25", "52": "r25", "53": "r25", "54": "r25", "55": "r25", "56": "r25", "57": "r25", "58": "r25" }, { "23": "r26", "24": "r26", "25": "r26", "26": "r26", "27": "r26", "28": "r26", "29": "r26", "30": "r26", "31": "r26", "32": "r26", "33": "r26", "34": "r26", "35": "r26", "36": "r26", "37": "r26", "38": "r26", "39": "r26", "40": "r26", "41": "r26", "42": "r26", "43": "r26", "44": "r26", "45": "r26", "46": "r26", "47": "r26", "48": "r26", "49": "r26", "50": "r26", "51": "r26", "52": "r26", "53": "r26", "54": "r26", "55": "r26", "56": "r26", "57": "r26", "58": "r26" }, { "23": "r27", "24": "r27", "25": "r27", "26": "r27", "27": "r27", "28": "r27", "29": "r27", "30": "r27", "31": "r27", "32": "r27", "33": "r27", "34": "r27", "35": "r27", "36": "r27", "37": "r27", "38": "r27", "39": "r27", "40": "r27", "41": "r27", "42": "r27", "43": "r27", "44": "r27", "45": "r27", "46": "r27", "47": "r27", "48": "r27", "49": "r27", "50": "r27", "51": "r27", "52": "r27", "53": "r27", "54": "r27", "55": "r27", "56": "r27", "57": "r27", "58": "r27" }, { "23": "r28", "24": "r28", "25": "r28", "26": "r28", "27": "r28", "28": "r28", "29": "r28", "30": "r28", "31": "r28", "32": "r28", "33": "r28", "34": "r28", "35": "r28", "36": "r28", "37": "r28", "38": "r28", "39": "r28", "40": "r28", "41": "r28", "42": "r28", "43": "r28", "44": "r28", "45": "r28", "46": "r28", "47": "r28", "48": "r28", "49": "r28", "50": "r28", "51": "r28", "52": "r28", "53": "r28", "54": "r28", "55": "r28", "56": "r28", "57": "r28", "58": "r28" }, { "23": "r29", "24": "r29", "25": "r29", "26": "r29", "27": "r29", "28": "r29", "29": "r29", "30": "r29", "31": "r29", "32": "r29", "33": "r29", "34": "r29", "35": "r29", "36": "r29", "37": "r29", "38": "r29", "39": "r29", "40": "r29", "41": "r29", "42": "r29", "43": "r29", "44": "r29", "45": "r29", "46": "r29", "47": "r29", "48": "r29", "49": "r29", "50": "r29", "51": "r29", "52": "r29", "53": "r29", "54": "r29", "55": "r29", "56": "r29", "57": "r29", "58": "r29" }, { "23": "r30", "24": "r30", "25": "r30", "26": "r30", "27": "r30", "28": "r30", "29": "r30", "30": "r30", "31": "r30", "32": "r30", "33": "r30", "34": "r30", "35": "r30", "36": "r30", "37": "r30", "38": "r30", "39": "r30", "40": "r30", "41": "r30", "42": "r30", "43": "r30", "44": "r30", "45": "r30", "46": "r30", "47": "r30", "48": "r30", "49": "r30", "50": "r30", "51": "r30", "52": "r30", "53": "r30", "54": "r30", "55": "r30", "56": "r30", "57": "r30", "58": "r30" }, { "23": "r31", "24": "r31", "25": "r31", "26": "r31", "27": "r31", "28": "r31", "29": "r31", "30": "r31", "31": "r31", "32": "r31", "33": "r31", "34": "r31", "35": "r31", "36": "r31", "37": "r31", "38": "r31", "39": "r31", "40": "r31", "41": "r31", "42": "r31", "43": "r31", "44": "r31", "45": "r31", "46": "r31", "47": "r31", "48": "r31", "49": "r31", "50": "r31", "51": "r31", "52": "r31", "53": "r31", "54": "r31", "55": "r31", "56": "r31", "57": "r31", "58": "r31" }, { "23": "r32", "24": "r32", "25": "r32", "26": "r32", "27": "r32", "28": "r32", "29": "r32", "30": "r32", "31": "r32", "32": "r32", "33": "r32", "34": "r32", "35": "r32", "36": "r32", "37": "r32", "38": "r32", "39": "r32", "40": "r32", "41": "r32", "42": "r32", "43": "r32", "44": "r32", "45": "r32", "46": "r32", "47": "r32", "48": "r32", "49": "r32", "50": "r32", "51": "r32", "52": "r32", "53": "r32", "54": "r32", "55": "r32", "56": "r32", "57": "r32", "58": "r32" }, { "23": "r33", "24": "r33", "25": "r33", "26": "r33", "27": "r33", "28": "r33", "29": "r33", "30": "r33", "31": "r33", "32": "r33", "33": "r33", "34": "r33", "35": "r33", "36": "r33", "37": "r33", "38": "r33", "39": "r33", "40": "r33", "41": "r33", "42": "r33", "43": "r33", "44": "r33", "45": "r33", "46": "r33", "47": "r33", "48": "r33", "49": "r33", "50": "r33", "51": "r33", "52": "r33", "53": "r33", "54": "r33", "55": "r33", "56": "r33", "57": "r33", "58": "r33" }, { "23": "r34", "24": "r34", "25": "r34", "26": "r34", "27": "r34", "28": "r34", "29": "r34", "30": "r34", "31": "r34", "32": "r34", "33": "r34", "34": "r34", "35": "r34", "36": "r34", "37": "r34", "38": "r34", "39": "r34", "40": "r34", "41": "r34", "42": "r34", "43": "r34", "44": "r34", "45": "r34", "46": "r34", "47": "r34", "48": "r34", "49": "r34", "50": "r34", "51": "r34", "52": "r34", "53": "r34", "54": "r34", "55": "r34", "56": "r34", "57": "r34", "58": "r34" }, { "23": "r35", "24": "r35", "25": "r35", "26": "r35", "27": "r35", "28": "r35", "29": "r35", "30": "r35", "31": "r35", "32": "r35", "33": "r35", "34": "r35", "35": "r35", "36": "r35", "37": "r35", "38": "r35", "39": "r35", "40": "r35", "41": "r35", "42": "r35", "43": "r35", "44": "r35", "45": "r35", "46": "r35", "47": "r35", "48": "r35", "49": "r35", "50": "r35", "51": "r35", "52": "r35", "53": "r35", "54": "r35", "55": "r35", "56": "r35", "57": "r35", "58": "r35" }, { "23": "r36", "24": "r36", "25": "r36", "26": "r36", "27": "r36", "28": "r36", "29": "r36", "30": "r36", "31": "r36", "32": "r36", "33": "r36", "34": "r36", "35": "r36", "36": "r36", "37": "r36", "38": "r36", "39": "r36", "40": "r36", "41": "r36", "42": "r36", "43": "r36", "44": "r36", "45": "r36", "46": "r36", "47": "r36", "48": "r36", "49": "r36", "50": "r36", "51": "r36", "52": "r36", "53": "r36", "54": "r36", "55": "r36", "56": "r36", "57": "r36", "58": "r36" }, { "10": 70, "18": 65, "19": 66, "21": 67, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r54", "58": "s68" }, { "10": 70, "18": 83, "19": 66, "21": 67, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r54", "58": "s68" }, { "23": "r47", "24": "r47", "25": "r47", "26": "r47", "27": "r47", "28": "r47", "29": "r47", "30": "r47", "31": "r47", "32": "r47", "33": "r47", "34": "r47", "35": "r47", "36": "r47", "37": "r47", "38": "r47", "39": "r47", "40": "r47", "41": "r47", "42": "r47", "43": "r47", "44": "r47", "45": "r47", "46": "r47", "47": "r47", "48": "r47", "49": "r47", "50": "r47", "51": "r47", "52": "r47", "53": "r47", "54": "r47", "55": "r47", "57": "r47" }, { "23": "r48", "24": "r48", "25": "r48", "26": "r48", "27": "r48", "28": "r48", "29": "r48", "30": "r48", "31": "r48", "32": "r48", "33": "r48", "34": "r48", "35": "r48", "36": "r48", "37": "r48", "38": "r48", "39": "r48", "40": "r48", "41": "r48", "42": "r48", "43": "r48", "44": "r48", "45": "r48", "46": "r48", "47": "r48", "48": "r48", "49": "r48", "50": "r48", "51": "r48", "52": "r48", "53": "r48", "54": "r48", "55": "r48", "57": "r48" }, { "4": 85, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "4": 87, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "4": 89, "5": 5, "6": 6, "24": "r10", "25": "r10", "26": "r10", "27": "r10", "28": "r10", "29": "r10", "30": "r10", "31": "r10", "32": "r10", "33": "r10", "34": "r10", "35": "r10", "36": "r10", "37": "r10", "38": "r10", "39": "r10", "40": "r10", "41": "r10", "42": "r10", "43": "r10", "44": "r10", "45": "r10", "52": "r10", "53": "r10", "54": "r10", "55": "r10", "57": "r10" }, { "23": "r13", "24": "r13", "25": "r13", "26": "r13", "27": "r13", "28": "r13", "29": "r13", "30": "r13", "31": "r13", "32": "r13", "33": "r13", "34": "r13", "35": "r13", "36": "r13", "37": "r13", "38": "r13", "39": "r13", "40": "r13", "41": "r13", "42": "r13", "43": "r13", "44": "r13", "45": "r13", "52": "r13", "53": "r13", "54": "r13", "55": "r13", "57": "r13" }, { "23": "r37", "24": "r37", "25": "r37", "26": "r37", "27": "r37", "28": "r37", "29": "r37", "30": "r37", "31": "r37", "32": "r37", "33": "r37", "34": "r37", "35": "r37", "36": "r37", "37": "r37", "38": "r37", "39": "r37", "40": "r37", "41": "r37", "42": "r37", "43": "r37", "44": "r37", "45": "r37", "52": "r37", "53": "r37", "54": "r37", "55": "r37", "57": "r37" }, { "23": "r39", "24": "r39", "25": "r39", "26": "r39", "27": "r39", "28": "r39", "29": "r39", "30": "r39", "31": "r39", "32": "r39", "33": "r39", "34": "r39", "35": "r39", "36": "r39", "37": "r39", "38": "r39", "39": "r39", "40": "r39", "41": "r39", "42": "r39", "43": "r39", "44": "r39", "45": "r39", "46": "s56", "52": "r39", "53": "r39", "54": "r39", "55": "r39", "57": "r39" }, { "23": "r41", "24": "r41", "25": "r41", "26": "r41", "27": "r41", "28": "r41", "29": "r41", "30": "r41", "31": "r41", "32": "r41", "33": "r41", "34": "r41", "35": "r41", "36": "r41", "37": "r41", "38": "r41", "39": "r41", "40": "r41", "41": "r41", "42": "r41", "43": "r41", "44": "r41", "45": "r41", "46": "r41", "52": "r41", "53": "r41", "54": "r41", "55": "r41", "57": "r41" }, { "23": "r42", "24": "r42", "25": "r42", "26": "r42", "27": "r42", "28": "r42", "29": "r42", "30": "r42", "31": "r42", "32": "r42", "33": "r42", "34": "r42", "35": "r42", "36": "r42", "37": "r42", "38": "r42", "39": "r42", "40": "r42", "41": "r42", "42": "r42", "43": "r42", "44": "r42", "45": "r42", "46": "r42", "52": "r42", "53": "r42", "54": "r42", "55": "r42", "57": "r42" }, { "23": "r43", "24": "r43", "25": "r43", "26": "r43", "27": "r43", "28": "r43", "29": "r43", "30": "r43", "31": "r43", "32": "r43", "33": "r43", "34": "r43", "35": "r43", "36": "r43", "37": "r43", "38": "r43", "39": "r43", "40": "r43", "41": "r43", "42": "r43", "43": "r43", "44": "r43", "45": "r43", "46": "r43", "52": "r43", "53": "r43", "54": "r43", "55": "r43", "57": "r43" }, { "23": "r44", "24": "r44", "25": "r44", "26": "r44", "27": "r44", "28": "r44", "29": "r44", "30": "r44", "31": "r44", "32": "r44", "33": "r44", "34": "r44", "35": "r44", "36": "r44", "37": "r44", "38": "r44", "39": "r44", "40": "r44", "41": "r44", "42": "r44", "43": "r44", "44": "r44", "45": "r44", "46": "r44", "52": "r44", "53": "r44", "54": "r44", "55": "r44", "57": "r44" }, { "23": "r45", "24": "r45", "25": "r45", "26": "r45", "27": "r45", "28": "r45", "29": "r45", "30": "r45", "31": "r45", "32": "r45", "33": "r45", "34": "r45", "35": "r45", "36": "r45", "37": "r45", "38": "r45", "39": "r45", "40": "r45", "41": "r45", "42": "r45", "43": "r45", "44": "r45", "45": "r45", "46": "r45", "52": "r45", "53": "r45", "54": "r45", "55": "r45", "57": "r45" }, { "23": "r46", "24": "r46", "25": "r46", "26": "r46", "27": "r46", "28": "r46", "29": "r46", "30": "r46", "31": "r46", "32": "r46", "33": "r46", "34": "r46", "35": "r46", "36": "r46", "37": "r46", "38": "r46", "39": "r46", "40": "r46", "41": "r46", "42": "r46", "43": "r46", "44": "r46", "45": "r46", "46": "r46", "52": "r46", "53": "r46", "54": "r46", "55": "r46", "57": "r46" }, { "23": "r40", "24": "r40", "25": "r40", "26": "r40", "27": "r40", "28": "r40", "29": "r40", "30": "r40", "31": "r40", "32": "r40", "33": "r40", "34": "r40", "35": "r40", "36": "r40", "37": "r40", "38": "r40", "39": "r40", "40": "r40", "41": "r40", "42": "r40", "43": "r40", "44": "r40", "45": "r40", "52": "r40", "53": "r40", "54": "r40", "55": "r40", "57": "r40" }, { "25": "s12", "31": "s58" }, { "23": "r18", "24": "r18", "25": "r18", "26": "r18", "27": "r18", "28": "r18", "29": "r18", "30": "r18", "31": "r18", "32": "r18", "33": "r18", "34": "r18", "35": "r18", "36": "r18", "37": "r18", "38": "r18", "39": "r18", "40": "r18", "41": "r18", "42": "r18", "43": "r18", "44": "r18", "45": "r18", "52": "r18", "53": "r18", "54": "r18", "55": "r18", "57": "r18" }, { "25": "s12", "31": "s60" }, { "23": "r19", "24": "r19", "25": "r19", "26": "r19", "27": "r19", "28": "r19", "29": "r19", "30": "r19", "31": "r19", "32": "r19", "33": "r19", "34": "r19", "35": "r19", "36": "r19", "37": "r19", "38": "r19", "39": "r19", "40": "r19", "41": "r19", "42": "r19", "43": "r19", "44": "r19", "45": "r19", "52": "r19", "53": "r19", "54": "r19", "55": "r19", "57": "r19" }, { "25": "s12", "31": "s62" }, { "23": "r20", "24": "r20", "25": "r20", "26": "r20", "27": "r20", "28": "r20", "29": "r20", "30": "r20", "31": "r20", "32": "r20", "33": "r20", "34": "r20", "35": "r20", "36": "r20", "37": "r20", "38": "r20", "39": "r20", "40": "r20", "41": "r20", "42": "r20", "43": "r20", "44": "r20", "45": "r20", "52": "r20", "53": "r20", "54": "r20", "55": "r20", "57": "r20" }, { "25": "s12", "31": "s64" }, { "23": "r21", "24": "r21", "25": "r21", "26": "r21", "27": "r21", "28": "r21", "29": "r21", "30": "r21", "31": "r21", "32": "r21", "33": "r21", "34": "r21", "35": "r21", "36": "r21", "37": "r21", "38": "r21", "39": "r21", "40": "r21", "41": "r21", "42": "r21", "43": "r21", "44": "r21", "45": "r21", "52": "r21", "53": "r21", "54": "r21", "55": "r21", "57": "r21" }, { "56": "s72" }, { "56": "r55" }, { "10": 70, "20": 73, "21": 75, "22": 76, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r56", "58": "s74" }, { "24": "r62", "28": "r62", "35": "r62", "36": "r62", "37": "r62", "38": "r62", "39": "r62", "40": "r62", "41": "r62", "42": "r62", "43": "r62", "44": "r62", "45": "r62", "56": "r62", "58": "r62" }, { "24": "r63", "28": "r63", "35": "r63", "36": "r63", "37": "r63", "38": "r63", "39": "r63", "40": "r63", "41": "r63", "42": "r63", "43": "r63", "44": "r63", "45": "r63", "56": "r63", "58": "r63" }, { "24": "r64", "28": "r64", "35": "r64", "36": "r64", "37": "r64", "38": "r64", "39": "r64", "40": "r64", "41": "r64", "42": "r64", "43": "r64", "44": "r64", "45": "r64", "56": "r64", "58": "r64" }, { "24": "r65", "28": "r65", "35": "r65", "36": "r65", "37": "r65", "38": "r65", "39": "r65", "40": "r65", "41": "r65", "42": "r65", "43": "r65", "44": "r65", "45": "r65", "56": "r65", "58": "r65" }, { "23": "r52", "24": "r52", "25": "r52", "26": "r52", "27": "r52", "28": "r52", "29": "r52", "30": "r52", "31": "r52", "32": "r52", "33": "r52", "34": "r52", "35": "r52", "36": "r52", "37": "r52", "38": "r52", "39": "r52", "40": "r52", "41": "r52", "42": "r52", "43": "r52", "44": "r52", "45": "r52", "46": "r52", "47": "r52", "48": "r52", "49": "r52", "50": "r52", "51": "r52", "52": "r52", "53": "r52", "54": "r52", "55": "r52", "57": "r52" }, { "56": "r57" }, { "10": 70, "21": 77, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r62", "58": "s68" }, { "56": "r59" }, { "10": 70, "20": 79, "21": 75, "22": 76, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r63", "58": "s80" }, { "10": 70, "18": 78, "19": 66, "21": 67, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r54", "58": "s68" }, { "56": "r58" }, { "56": "r60" }, { "10": 70, "21": 81, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r62", "58": "s68" }, { "10": 70, "18": 82, "19": 66, "21": 67, "22": 69, "24": "s28", "28": "s71", "35": "s29", "36": "s30", "37": "s31", "38": "s32", "39": "s33", "40": "s34", "41": "s35", "42": "s36", "43": "s37", "44": "s38", "45": "s39", "56": "r54", "58": "s68" }, { "56": "r61" }, { "56": "s84" }, { "23": "r53", "24": "r53", "25": "r53", "26": "r53", "27": "r53", "28": "r53", "29": "r53", "30": "r53", "31": "r53", "32": "r53", "33": "r53", "34": "r53", "35": "r53", "36": "r53", "37": "r53", "38": "r53", "39": "r53", "40": "r53", "41": "r53", "42": "r53", "43": "r53", "44": "r53", "45": "r53", "46": "r53", "47": "r53", "48": "r53", "49": "r53", "50": "r53", "51": "r53", "52": "r53", "53": "r53", "54": "r53", "55": "r53", "57": "r53" }, { "25": "s12", "31": "s86" }, { "23": "r49", "24": "r49", "25": "r49", "26": "r49", "27": "r49", "28": "r49", "29": "r49", "30": "r49", "31": "r49", "32": "r49", "33": "r49", "34": "r49", "35": "r49", "36": "r49", "37": "r49", "38": "r49", "39": "r49", "40": "r49", "41": "r49", "42": "r49", "43": "r49", "44": "r49", "45": "r49", "46": "r49", "47": "r49", "48": "r49", "49": "r49", "50": "r49", "51": "r49", "52": "r49", "53": "r49", "54": "r49", "55": "r49", "57": "r49" }, { "25": "s12", "31": "s88" }, { "23": "r50", "24": "r50", "25": "r50", "26": "r50", "27": "r50", "28": "r50", "29": "r50", "30": "r50", "31": "r50", "32": "r50", "33": "r50", "34": "r50", "35": "r50", "36": "r50", "37": "r50", "38": "r50", "39": "r50", "40": "r50", "41": "r50", "42": "r50", "43": "r50", "44": "r50", "45": "r50", "46": "r50", "47": "r50", "48": "r50", "49": "r50", "50": "r50", "51": "r50", "52": "r50", "53": "r50", "54": "r50", "55": "r50", "57": "r50" }, { "25": "s12", "31": "s90" }, { "23": "r51", "24": "r51", "25": "r51", "26": "r51", "27": "r51", "28": "r51", "29": "r51", "30": "r51", "31": "r51", "32": "r51", "33": "r51", "34": "r51", "35": "r51", "36": "r51", "37": "r51", "38": "r51", "39": "r51", "40": "r51", "41": "r51", "42": "r51", "43": "r51", "44": "r51", "45": "r51", "46": "r51", "47": "r51", "48": "r51", "49": "r51", "50": "r51", "51": "r51", "52": "r51", "53": "r51", "54": "r51", "55": "r51", "57": "r51" }];
|
|
|
|
/**
|
|
* Parsing stack.
|
|
*/
|
|
var stack = [];
|
|
|
|
/**
|
|
* Tokenizer instance.
|
|
*/
|
|
var tokenizer = void 0;
|
|
/**
|
|
* Generic tokenizer used by the parser in the Syntax tool.
|
|
*
|
|
* https://www.npmjs.com/package/syntax-cli
|
|
*
|
|
* See `--custom-tokinzer` to skip this generation, and use a custom one.
|
|
*/
|
|
|
|
var lexRules = [[/^#[^\n]+/, function () {/* skip comments */}], [/^\s+/, function () {/* skip whitespace */}], [/^-/, function () {
|
|
return 'DASH';
|
|
}], [/^\//, function () {
|
|
return 'CHAR';
|
|
}], [/^#/, function () {
|
|
return 'CHAR';
|
|
}], [/^\|/, function () {
|
|
return 'CHAR';
|
|
}], [/^\./, function () {
|
|
return 'CHAR';
|
|
}], [/^\{/, function () {
|
|
return 'CHAR';
|
|
}], [/^\{\d+\}/, function () {
|
|
return 'RANGE_EXACT';
|
|
}], [/^\{\d+,\}/, function () {
|
|
return 'RANGE_OPEN';
|
|
}], [/^\{\d+,\d+\}/, function () {
|
|
return 'RANGE_CLOSED';
|
|
}], [/^\\k<(([\u0041-\u005a\u0061-\u007a\u00aa\u00b5\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]|\ud800[\udc00-\udc0b\udc0d-\udc26\udc28-\udc3a\udc3c-\udc3d\udc3f-\udc4d\udc50-\udc5d\udc80-\udcfa\udd40-\udd74\ude80-\ude9c\udea0-\uded0\udf00-\udf1f\udf2d-\udf4a\udf50-\udf75\udf80-\udf9d\udfa0-\udfc3\udfc8-\udfcf\udfd1-\udfd5]|\ud801[\udc00-\udc9d\udcb0-\udcd3\udcd8-\udcfb\udd00-\udd27\udd30-\udd63\ude00-\udf36\udf40-\udf55\udf60-\udf67]|\ud802[\udc00-\udc05\udc08\udc0a-\udc35\udc37-\udc38\udc3c\udc3f-\udc55\udc60-\udc76\udc80-\udc9e\udce0-\udcf2\udcf4-\udcf5\udd00-\udd15\udd20-\udd39\udd80-\uddb7\uddbe-\uddbf\ude00\ude10-\ude13\ude15-\ude17\ude19-\ude35\ude60-\ude7c\ude80-\ude9c\udec0-\udec7\udec9-\udee4\udf00-\udf35\udf40-\udf55\udf60-\udf72\udf80-\udf91]|\ud803[\udc00-\udc48\udc80-\udcb2\udcc0-\udcf2\udd00-\udd23\udf00-\udf1c\udf27\udf30-\udf45\udfe0-\udff6]|\ud804[\udc03-\udc37\udc83-\udcaf\udcd0-\udce8\udd03-\udd26\udd44\udd50-\udd72\udd76\udd83-\uddb2\uddc1-\uddc4\uddda\udddc\ude00-\ude11\ude13-\ude2b\ude80-\ude86\ude88\ude8a-\ude8d\ude8f-\ude9d\ude9f-\udea8\udeb0-\udede\udf05-\udf0c\udf0f-\udf10\udf13-\udf28\udf2a-\udf30\udf32-\udf33\udf35-\udf39\udf3d\udf50\udf5d-\udf61]|\ud805[\udc00-\udc34\udc47-\udc4a\udc5f\udc80-\udcaf\udcc4-\udcc5\udcc7\udd80-\uddae\uddd8-\udddb\ude00-\ude2f\ude44\ude80-\udeaa\udeb8\udf00-\udf1a]|\ud806[\udc00-\udc2b\udca0-\udcdf\udcff\udda0-\udda7\uddaa-\uddd0\udde1\udde3\ude00\ude0b-\ude32\ude3a\ude50\ude5c-\ude89\ude9d\udec0-\udef8]|\ud807[\udc00-\udc08\udc0a-\udc2e\udc40\udc72-\udc8f\udd00-\udd06\udd08-\udd09\udd0b-\udd30\udd46\udd60-\udd65\udd67-\udd68\udd6a-\udd89\udd98\udee0-\udef2]|\ud808[\udc00-\udf99]|\ud809[\udc00-\udc6e\udc80-\udd43]|\ud80c[\udc00-\udfff]|\ud80d[\udc00-\udc2e]|\ud811[\udc00-\ude46]|\ud81a[\udc00-\ude38\ude40-\ude5e\uded0-\udeed\udf00-\udf2f\udf40-\udf43\udf63-\udf77\udf7d-\udf8f]|\ud81b[\ude40-\ude7f\udf00-\udf4a\udf50\udf93-\udf9f\udfe0-\udfe1\udfe3]|\ud81c[\udc00-\udfff]|\ud81d[\udc00-\udfff]|\ud81e[\udc00-\udfff]|\ud81f[\udc00-\udfff]|\ud820[\udc00-\udfff]|\ud821[\udc00-\udff7]|\ud822[\udc00-\udef2]|\ud82c[\udc00-\udd1e\udd50-\udd52\udd64-\udd67\udd70-\udefb]|\ud82f[\udc00-\udc6a\udc70-\udc7c\udc80-\udc88\udc90-\udc99]|\ud835[\udc00-\udc54\udc56-\udc9c\udc9e-\udc9f\udca2\udca5-\udca6\udca9-\udcac\udcae-\udcb9\udcbb\udcbd-\udcc3\udcc5-\udd05\udd07-\udd0a\udd0d-\udd14\udd16-\udd1c\udd1e-\udd39\udd3b-\udd3e\udd40-\udd44\udd46\udd4a-\udd50\udd52-\udea5\udea8-\udec0\udec2-\udeda\udedc-\udefa\udefc-\udf14\udf16-\udf34\udf36-\udf4e\udf50-\udf6e\udf70-\udf88\udf8a-\udfa8\udfaa-\udfc2\udfc4-\udfcb]|\ud838[\udd00-\udd2c\udd37-\udd3d\udd4e\udec0-\udeeb]|\ud83a[\udc00-\udcc4\udd00-\udd43\udd4b]|\ud83b[\ude00-\ude03\ude05-\ude1f\ude21-\ude22\ude24\ude27\ude29-\ude32\ude34-\ude37\ude39\ude3b\ude42\ude47\ude49\ude4b\ude4d-\ude4f\ude51-\ude52\ude54\ude57\ude59\ude5b\ude5d\ude5f\ude61-\ude62\ude64\ude67-\ude6a\ude6c-\ude72\ude74-\ude77\ude79-\ude7c\ude7e\ude80-\ude89\ude8b-\ude9b\udea1-\udea3\udea5-\udea9\udeab-\udebb]|\ud840[\udc00-\udfff]|\ud841[\udc00-\udfff]|\ud842[\udc00-\udfff]|\ud843[\udc00-\udfff]|\ud844[\udc00-\udfff]|\ud845[\udc00-\udfff]|\ud846[\udc00-\udfff]|\ud847[\udc00-\udfff]|\ud848[\udc00-\udfff]|\ud849[\udc00-\udfff]|\ud84a[\udc00-\udfff]|\ud84b[\udc00-\udfff]|\ud84c[\udc00-\udfff]|\ud84d[\udc00-\udfff]|\ud84e[\udc00-\udfff]|\ud84f[\udc00-\udfff]|\ud850[\udc00-\udfff]|\ud851[\udc00-\udfff]|\ud852[\udc00-\udfff]|\ud853[\udc00-\udfff]|\ud854[\udc00-\udfff]|\ud855[\udc00-\udfff]|\ud856[\udc00-\udfff]|\ud857[\udc00-\udfff]|\ud858[\udc00-\udfff]|\ud859[\udc00-\udfff]|\ud85a[\udc00-\udfff]|\ud85b[\udc00-\udfff]|\ud85c[\udc00-\udfff]|\ud85d[\udc00-\udfff]|\ud85e[\udc00-\udfff]|\ud85f[\udc00-\udfff]|\ud860[\udc00-\udfff]|\ud861[\udc00-\udfff]|\ud862[\udc00-\udfff]|\ud863[\udc00-\udfff]|\ud864[\udc00-\udfff]|\ud865[\udc00-\udfff]|\ud866[\udc00-\udfff]|\ud867[\udc00-\udfff]|\ud868[\udc00-\udfff]|\ud869[\udc00-\uded6\udf00-\udfff]|\ud86a[\udc00-\udfff]|\ud86b[\udc00-\udfff]|\ud86c[\udc00-\udfff]|\ud86d[\udc00-\udf34\udf40-\udfff]|\ud86e[\udc00-\udc1d\udc20-\udfff]|\ud86f[\udc00-\udfff]|\ud870[\udc00-\udfff]|\ud871[\udc00-\udfff]|\ud872[\udc00-\udfff]|\ud873[\udc00-\udea1\udeb0-\udfff]|\ud874[\udc00-\udfff]|\ud875[\udc00-\udfff]|\ud876[\udc00-\udfff]|\ud877[\udc00-\udfff]|\ud878[\udc00-\udfff]|\ud879[\udc00-\udfff]|\ud87a[\udc00-\udfe0]|\ud87e[\udc00-\ude1d])|[$_]|(\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]{1,}\}))(([\u0030-\u0039\u0041-\u005a\u005f\u0061-\u007a\u00aa\u00b5\u00b7\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u08d3-\u08e1\u08e3-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf2\u0d00-\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1369-\u1371\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1ab0-\u1abd\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1df9\u1dfb-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u203f-\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua827\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]|\ud800[\udc00-\udc0b\udc0d-\udc26\udc28-\udc3a\udc3c-\udc3d\udc3f-\udc4d\udc50-\udc5d\udc80-\udcfa\udd40-\udd74\uddfd\ude80-\ude9c\udea0-\uded0\udee0\udf00-\udf1f\udf2d-\udf4a\udf50-\udf7a\udf80-\udf9d\udfa0-\udfc3\udfc8-\udfcf\udfd1-\udfd5]|\ud801[\udc00-\udc9d\udca0-\udca9\udcb0-\udcd3\udcd8-\udcfb\udd00-\udd27\udd30-\udd63\ude00-\udf36\udf40-\udf55\udf60-\udf67]|\ud802[\udc00-\udc05\udc08\udc0a-\udc35\udc37-\udc38\udc3c\udc3f-\udc55\udc60-\udc76\udc80-\udc9e\udce0-\udcf2\udcf4-\udcf5\udd00-\udd15\udd20-\udd39\udd80-\uddb7\uddbe-\uddbf\ude00-\ude03\ude05-\ude06\ude0c-\ude13\ude15-\ude17\ude19-\ude35\ude38-\ude3a\ude3f\ude60-\ude7c\ude80-\ude9c\udec0-\udec7\udec9-\udee6\udf00-\udf35\udf40-\udf55\udf60-\udf72\udf80-\udf91]|\ud803[\udc00-\udc48\udc80-\udcb2\udcc0-\udcf2\udd00-\udd27\udd30-\udd39\udf00-\udf1c\udf27\udf30-\udf50\udfe0-\udff6]|\ud804[\udc00-\udc46\udc66-\udc6f\udc7f-\udcba\udcd0-\udce8\udcf0-\udcf9\udd00-\udd34\udd36-\udd3f\udd44-\udd46\udd50-\udd73\udd76\udd80-\uddc4\uddc9-\uddcc\uddd0-\uddda\udddc\ude00-\ude11\ude13-\ude37\ude3e\ude80-\ude86\ude88\ude8a-\ude8d\ude8f-\ude9d\ude9f-\udea8\udeb0-\udeea\udef0-\udef9\udf00-\udf03\udf05-\udf0c\udf0f-\udf10\udf13-\udf28\udf2a-\udf30\udf32-\udf33\udf35-\udf39\udf3b-\udf44\udf47-\udf48\udf4b-\udf4d\udf50\udf57\udf5d-\udf63\udf66-\udf6c\udf70-\udf74]|\ud805[\udc00-\udc4a\udc50-\udc59\udc5e-\udc5f\udc80-\udcc5\udcc7\udcd0-\udcd9\udd80-\uddb5\uddb8-\uddc0\uddd8-\udddd\ude00-\ude40\ude44\ude50-\ude59\ude80-\udeb8\udec0-\udec9\udf00-\udf1a\udf1d-\udf2b\udf30-\udf39]|\ud806[\udc00-\udc3a\udca0-\udce9\udcff\udda0-\udda7\uddaa-\uddd7\uddda-\udde1\udde3-\udde4\ude00-\ude3e\ude47\ude50-\ude99\ude9d\udec0-\udef8]|\ud807[\udc00-\udc08\udc0a-\udc36\udc38-\udc40\udc50-\udc59\udc72-\udc8f\udc92-\udca7\udca9-\udcb6\udd00-\udd06\udd08-\udd09\udd0b-\udd36\udd3a\udd3c-\udd3d\udd3f-\udd47\udd50-\udd59\udd60-\udd65\udd67-\udd68\udd6a-\udd8e\udd90-\udd91\udd93-\udd98\udda0-\udda9\udee0-\udef6]|\ud808[\udc00-\udf99]|\ud809[\udc00-\udc6e\udc80-\udd43]|\ud80c[\udc00-\udfff]|\ud80d[\udc00-\udc2e]|\ud811[\udc00-\ude46]|\ud81a[\udc00-\ude38\ude40-\ude5e\ude60-\ude69\uded0-\udeed\udef0-\udef4\udf00-\udf36\udf40-\udf43\udf50-\udf59\udf63-\udf77\udf7d-\udf8f]|\ud81b[\ude40-\ude7f\udf00-\udf4a\udf4f-\udf87\udf8f-\udf9f\udfe0-\udfe1\udfe3]|\ud81c[\udc00-\udfff]|\ud81d[\udc00-\udfff]|\ud81e[\udc00-\udfff]|\ud81f[\udc00-\udfff]|\ud820[\udc00-\udfff]|\ud821[\udc00-\udff7]|\ud822[\udc00-\udef2]|\ud82c[\udc00-\udd1e\udd50-\udd52\udd64-\udd67\udd70-\udefb]|\ud82f[\udc00-\udc6a\udc70-\udc7c\udc80-\udc88\udc90-\udc99\udc9d-\udc9e]|\ud834[\udd65-\udd69\udd6d-\udd72\udd7b-\udd82\udd85-\udd8b\uddaa-\uddad\ude42-\ude44]|\ud835[\udc00-\udc54\udc56-\udc9c\udc9e-\udc9f\udca2\udca5-\udca6\udca9-\udcac\udcae-\udcb9\udcbb\udcbd-\udcc3\udcc5-\udd05\udd07-\udd0a\udd0d-\udd14\udd16-\udd1c\udd1e-\udd39\udd3b-\udd3e\udd40-\udd44\udd46\udd4a-\udd50\udd52-\udea5\udea8-\udec0\udec2-\udeda\udedc-\udefa\udefc-\udf14\udf16-\udf34\udf36-\udf4e\udf50-\udf6e\udf70-\udf88\udf8a-\udfa8\udfaa-\udfc2\udfc4-\udfcb\udfce-\udfff]|\ud836[\ude00-\ude36\ude3b-\ude6c\ude75\ude84\ude9b-\ude9f\udea1-\udeaf]|\ud838[\udc00-\udc06\udc08-\udc18\udc1b-\udc21\udc23-\udc24\udc26-\udc2a\udd00-\udd2c\udd30-\udd3d\udd40-\udd49\udd4e\udec0-\udef9]|\ud83a[\udc00-\udcc4\udcd0-\udcd6\udd00-\udd4b\udd50-\udd59]|\ud83b[\ude00-\ude03\ude05-\ude1f\ude21-\ude22\ude24\ude27\ude29-\ude32\ude34-\ude37\ude39\ude3b\ude42\ude47\ude49\ude4b\ude4d-\ude4f\ude51-\ude52\ude54\ude57\ude59\ude5b\ude5d\ude5f\ude61-\ude62\ude64\ude67-\ude6a\ude6c-\ude72\ude74-\ude77\ude79-\ude7c\ude7e\ude80-\ude89\ude8b-\ude9b\udea1-\udea3\udea5-\udea9\udeab-\udebb]|\ud840[\udc00-\udfff]|\ud841[\udc00-\udfff]|\ud842[\udc00-\udfff]|\ud843[\udc00-\udfff]|\ud844[\udc00-\udfff]|\ud845[\udc00-\udfff]|\ud846[\udc00-\udfff]|\ud847[\udc00-\udfff]|\ud848[\udc00-\udfff]|\ud849[\udc00-\udfff]|\ud84a[\udc00-\udfff]|\ud84b[\udc00-\udfff]|\ud84c[\udc00-\udfff]|\ud84d[\udc00-\udfff]|\ud84e[\udc00-\udfff]|\ud84f[\udc00-\udfff]|\ud850[\udc00-\udfff]|\ud851[\udc00-\udfff]|\ud852[\udc00-\udfff]|\ud853[\udc00-\udfff]|\ud854[\udc00-\udfff]|\ud855[\udc00-\udfff]|\ud856[\udc00-\udfff]|\ud857[\udc00-\udfff]|\ud858[\udc00-\udfff]|\ud859[\udc00-\udfff]|\ud85a[\udc00-\udfff]|\ud85b[\udc00-\udfff]|\ud85c[\udc00-\udfff]|\ud85d[\udc00-\udfff]|\ud85e[\udc00-\udfff]|\ud85f[\udc00-\udfff]|\ud860[\udc00-\udfff]|\ud861[\udc00-\udfff]|\ud862[\udc00-\udfff]|\ud863[\udc00-\udfff]|\ud864[\udc00-\udfff]|\ud865[\udc00-\udfff]|\ud866[\udc00-\udfff]|\ud867[\udc00-\udfff]|\ud868[\udc00-\udfff]|\ud869[\udc00-\uded6\udf00-\udfff]|\ud86a[\udc00-\udfff]|\ud86b[\udc00-\udfff]|\ud86c[\udc00-\udfff]|\ud86d[\udc00-\udf34\udf40-\udfff]|\ud86e[\udc00-\udc1d\udc20-\udfff]|\ud86f[\udc00-\udfff]|\ud870[\udc00-\udfff]|\ud871[\udc00-\udfff]|\ud872[\udc00-\udfff]|\ud873[\udc00-\udea1\udeb0-\udfff]|\ud874[\udc00-\udfff]|\ud875[\udc00-\udfff]|\ud876[\udc00-\udfff]|\ud877[\udc00-\udfff]|\ud878[\udc00-\udfff]|\ud879[\udc00-\udfff]|\ud87a[\udc00-\udfe0]|\ud87e[\udc00-\ude1d]|\udb40[\udd00-\uddef])|[$_]|(\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]{1,}\})|[\u200c\u200d])*>/, function () {
|
|
var groupName = yytext.slice(3, -1);
|
|
validateUnicodeGroupName(groupName, this.getCurrentState());
|
|
return 'NAMED_GROUP_REF';
|
|
}], [/^\\b/, function () {
|
|
return 'ESC_b';
|
|
}], [/^\\B/, function () {
|
|
return 'ESC_B';
|
|
}], [/^\\c[a-zA-Z]/, function () {
|
|
return 'CTRL_CH';
|
|
}], [/^\\0\d{1,2}/, function () {
|
|
return 'OCT_CODE';
|
|
}], [/^\\0/, function () {
|
|
return 'DEC_CODE';
|
|
}], [/^\\\d{1,3}/, function () {
|
|
return 'DEC_CODE';
|
|
}], [/^\\u[dD][89abAB][0-9a-fA-F]{2}\\u[dD][c-fC-F][0-9a-fA-F]{2}/, function () {
|
|
return 'U_CODE_SURROGATE';
|
|
}], [/^\\u\{[0-9a-fA-F]{1,}\}/, function () {
|
|
return 'U_CODE';
|
|
}], [/^\\u[0-9a-fA-F]{4}/, function () {
|
|
return 'U_CODE';
|
|
}], [/^\\[pP]\{\w+(?:=\w+)?\}/, function () {
|
|
return 'U_PROP_VALUE_EXP';
|
|
}], [/^\\x[0-9a-fA-F]{2}/, function () {
|
|
return 'HEX_CODE';
|
|
}], [/^\\[tnrdDsSwWvf]/, function () {
|
|
return 'META_CHAR';
|
|
}], [/^\\\//, function () {
|
|
return 'ESC_CHAR';
|
|
}], [/^\\[ #]/, function () {
|
|
return 'ESC_CHAR';
|
|
}], [/^\\[\^\$\.\*\+\?\(\)\\\[\]\{\}\|\/]/, function () {
|
|
return 'ESC_CHAR';
|
|
}], [/^\\[^*?+\[()\\|]/, function () {
|
|
var s = this.getCurrentState();
|
|
if (s === 'u_class' && yytext === "\\-") {
|
|
return 'ESC_CHAR';
|
|
} else if (s === 'u' || s === 'xu' || s === 'u_class') {
|
|
throw new SyntaxError('invalid Unicode escape ' + yytext);
|
|
}
|
|
return 'ESC_CHAR';
|
|
}], [/^\(/, function () {
|
|
return 'CHAR';
|
|
}], [/^\)/, function () {
|
|
return 'CHAR';
|
|
}], [/^\(\?=/, function () {
|
|
return 'POS_LA_ASSERT';
|
|
}], [/^\(\?!/, function () {
|
|
return 'NEG_LA_ASSERT';
|
|
}], [/^\(\?<=/, function () {
|
|
return 'POS_LB_ASSERT';
|
|
}], [/^\(\?<!/, function () {
|
|
return 'NEG_LB_ASSERT';
|
|
}], [/^\(\?:/, function () {
|
|
return 'NON_CAPTURE_GROUP';
|
|
}], [/^\(\?<(([\u0041-\u005a\u0061-\u007a\u00aa\u00b5\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]|\ud800[\udc00-\udc0b\udc0d-\udc26\udc28-\udc3a\udc3c-\udc3d\udc3f-\udc4d\udc50-\udc5d\udc80-\udcfa\udd40-\udd74\ude80-\ude9c\udea0-\uded0\udf00-\udf1f\udf2d-\udf4a\udf50-\udf75\udf80-\udf9d\udfa0-\udfc3\udfc8-\udfcf\udfd1-\udfd5]|\ud801[\udc00-\udc9d\udcb0-\udcd3\udcd8-\udcfb\udd00-\udd27\udd30-\udd63\ude00-\udf36\udf40-\udf55\udf60-\udf67]|\ud802[\udc00-\udc05\udc08\udc0a-\udc35\udc37-\udc38\udc3c\udc3f-\udc55\udc60-\udc76\udc80-\udc9e\udce0-\udcf2\udcf4-\udcf5\udd00-\udd15\udd20-\udd39\udd80-\uddb7\uddbe-\uddbf\ude00\ude10-\ude13\ude15-\ude17\ude19-\ude35\ude60-\ude7c\ude80-\ude9c\udec0-\udec7\udec9-\udee4\udf00-\udf35\udf40-\udf55\udf60-\udf72\udf80-\udf91]|\ud803[\udc00-\udc48\udc80-\udcb2\udcc0-\udcf2\udd00-\udd23\udf00-\udf1c\udf27\udf30-\udf45\udfe0-\udff6]|\ud804[\udc03-\udc37\udc83-\udcaf\udcd0-\udce8\udd03-\udd26\udd44\udd50-\udd72\udd76\udd83-\uddb2\uddc1-\uddc4\uddda\udddc\ude00-\ude11\ude13-\ude2b\ude80-\ude86\ude88\ude8a-\ude8d\ude8f-\ude9d\ude9f-\udea8\udeb0-\udede\udf05-\udf0c\udf0f-\udf10\udf13-\udf28\udf2a-\udf30\udf32-\udf33\udf35-\udf39\udf3d\udf50\udf5d-\udf61]|\ud805[\udc00-\udc34\udc47-\udc4a\udc5f\udc80-\udcaf\udcc4-\udcc5\udcc7\udd80-\uddae\uddd8-\udddb\ude00-\ude2f\ude44\ude80-\udeaa\udeb8\udf00-\udf1a]|\ud806[\udc00-\udc2b\udca0-\udcdf\udcff\udda0-\udda7\uddaa-\uddd0\udde1\udde3\ude00\ude0b-\ude32\ude3a\ude50\ude5c-\ude89\ude9d\udec0-\udef8]|\ud807[\udc00-\udc08\udc0a-\udc2e\udc40\udc72-\udc8f\udd00-\udd06\udd08-\udd09\udd0b-\udd30\udd46\udd60-\udd65\udd67-\udd68\udd6a-\udd89\udd98\udee0-\udef2]|\ud808[\udc00-\udf99]|\ud809[\udc00-\udc6e\udc80-\udd43]|\ud80c[\udc00-\udfff]|\ud80d[\udc00-\udc2e]|\ud811[\udc00-\ude46]|\ud81a[\udc00-\ude38\ude40-\ude5e\uded0-\udeed\udf00-\udf2f\udf40-\udf43\udf63-\udf77\udf7d-\udf8f]|\ud81b[\ude40-\ude7f\udf00-\udf4a\udf50\udf93-\udf9f\udfe0-\udfe1\udfe3]|\ud81c[\udc00-\udfff]|\ud81d[\udc00-\udfff]|\ud81e[\udc00-\udfff]|\ud81f[\udc00-\udfff]|\ud820[\udc00-\udfff]|\ud821[\udc00-\udff7]|\ud822[\udc00-\udef2]|\ud82c[\udc00-\udd1e\udd50-\udd52\udd64-\udd67\udd70-\udefb]|\ud82f[\udc00-\udc6a\udc70-\udc7c\udc80-\udc88\udc90-\udc99]|\ud835[\udc00-\udc54\udc56-\udc9c\udc9e-\udc9f\udca2\udca5-\udca6\udca9-\udcac\udcae-\udcb9\udcbb\udcbd-\udcc3\udcc5-\udd05\udd07-\udd0a\udd0d-\udd14\udd16-\udd1c\udd1e-\udd39\udd3b-\udd3e\udd40-\udd44\udd46\udd4a-\udd50\udd52-\udea5\udea8-\udec0\udec2-\udeda\udedc-\udefa\udefc-\udf14\udf16-\udf34\udf36-\udf4e\udf50-\udf6e\udf70-\udf88\udf8a-\udfa8\udfaa-\udfc2\udfc4-\udfcb]|\ud838[\udd00-\udd2c\udd37-\udd3d\udd4e\udec0-\udeeb]|\ud83a[\udc00-\udcc4\udd00-\udd43\udd4b]|\ud83b[\ude00-\ude03\ude05-\ude1f\ude21-\ude22\ude24\ude27\ude29-\ude32\ude34-\ude37\ude39\ude3b\ude42\ude47\ude49\ude4b\ude4d-\ude4f\ude51-\ude52\ude54\ude57\ude59\ude5b\ude5d\ude5f\ude61-\ude62\ude64\ude67-\ude6a\ude6c-\ude72\ude74-\ude77\ude79-\ude7c\ude7e\ude80-\ude89\ude8b-\ude9b\udea1-\udea3\udea5-\udea9\udeab-\udebb]|\ud840[\udc00-\udfff]|\ud841[\udc00-\udfff]|\ud842[\udc00-\udfff]|\ud843[\udc00-\udfff]|\ud844[\udc00-\udfff]|\ud845[\udc00-\udfff]|\ud846[\udc00-\udfff]|\ud847[\udc00-\udfff]|\ud848[\udc00-\udfff]|\ud849[\udc00-\udfff]|\ud84a[\udc00-\udfff]|\ud84b[\udc00-\udfff]|\ud84c[\udc00-\udfff]|\ud84d[\udc00-\udfff]|\ud84e[\udc00-\udfff]|\ud84f[\udc00-\udfff]|\ud850[\udc00-\udfff]|\ud851[\udc00-\udfff]|\ud852[\udc00-\udfff]|\ud853[\udc00-\udfff]|\ud854[\udc00-\udfff]|\ud855[\udc00-\udfff]|\ud856[\udc00-\udfff]|\ud857[\udc00-\udfff]|\ud858[\udc00-\udfff]|\ud859[\udc00-\udfff]|\ud85a[\udc00-\udfff]|\ud85b[\udc00-\udfff]|\ud85c[\udc00-\udfff]|\ud85d[\udc00-\udfff]|\ud85e[\udc00-\udfff]|\ud85f[\udc00-\udfff]|\ud860[\udc00-\udfff]|\ud861[\udc00-\udfff]|\ud862[\udc00-\udfff]|\ud863[\udc00-\udfff]|\ud864[\udc00-\udfff]|\ud865[\udc00-\udfff]|\ud866[\udc00-\udfff]|\ud867[\udc00-\udfff]|\ud868[\udc00-\udfff]|\ud869[\udc00-\uded6\udf00-\udfff]|\ud86a[\udc00-\udfff]|\ud86b[\udc00-\udfff]|\ud86c[\udc00-\udfff]|\ud86d[\udc00-\udf34\udf40-\udfff]|\ud86e[\udc00-\udc1d\udc20-\udfff]|\ud86f[\udc00-\udfff]|\ud870[\udc00-\udfff]|\ud871[\udc00-\udfff]|\ud872[\udc00-\udfff]|\ud873[\udc00-\udea1\udeb0-\udfff]|\ud874[\udc00-\udfff]|\ud875[\udc00-\udfff]|\ud876[\udc00-\udfff]|\ud877[\udc00-\udfff]|\ud878[\udc00-\udfff]|\ud879[\udc00-\udfff]|\ud87a[\udc00-\udfe0]|\ud87e[\udc00-\ude1d])|[$_]|(\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]{1,}\}))(([\u0030-\u0039\u0041-\u005a\u005f\u0061-\u007a\u00aa\u00b5\u00b7\u00ba\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u08d3-\u08e1\u08e3-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf2\u0d00-\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1369-\u1371\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1ab0-\u1abd\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1df9\u1dfb-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u203f-\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua827\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]|\ud800[\udc00-\udc0b\udc0d-\udc26\udc28-\udc3a\udc3c-\udc3d\udc3f-\udc4d\udc50-\udc5d\udc80-\udcfa\udd40-\udd74\uddfd\ude80-\ude9c\udea0-\uded0\udee0\udf00-\udf1f\udf2d-\udf4a\udf50-\udf7a\udf80-\udf9d\udfa0-\udfc3\udfc8-\udfcf\udfd1-\udfd5]|\ud801[\udc00-\udc9d\udca0-\udca9\udcb0-\udcd3\udcd8-\udcfb\udd00-\udd27\udd30-\udd63\ude00-\udf36\udf40-\udf55\udf60-\udf67]|\ud802[\udc00-\udc05\udc08\udc0a-\udc35\udc37-\udc38\udc3c\udc3f-\udc55\udc60-\udc76\udc80-\udc9e\udce0-\udcf2\udcf4-\udcf5\udd00-\udd15\udd20-\udd39\udd80-\uddb7\uddbe-\uddbf\ude00-\ude03\ude05-\ude06\ude0c-\ude13\ude15-\ude17\ude19-\ude35\ude38-\ude3a\ude3f\ude60-\ude7c\ude80-\ude9c\udec0-\udec7\udec9-\udee6\udf00-\udf35\udf40-\udf55\udf60-\udf72\udf80-\udf91]|\ud803[\udc00-\udc48\udc80-\udcb2\udcc0-\udcf2\udd00-\udd27\udd30-\udd39\udf00-\udf1c\udf27\udf30-\udf50\udfe0-\udff6]|\ud804[\udc00-\udc46\udc66-\udc6f\udc7f-\udcba\udcd0-\udce8\udcf0-\udcf9\udd00-\udd34\udd36-\udd3f\udd44-\udd46\udd50-\udd73\udd76\udd80-\uddc4\uddc9-\uddcc\uddd0-\uddda\udddc\ude00-\ude11\ude13-\ude37\ude3e\ude80-\ude86\ude88\ude8a-\ude8d\ude8f-\ude9d\ude9f-\udea8\udeb0-\udeea\udef0-\udef9\udf00-\udf03\udf05-\udf0c\udf0f-\udf10\udf13-\udf28\udf2a-\udf30\udf32-\udf33\udf35-\udf39\udf3b-\udf44\udf47-\udf48\udf4b-\udf4d\udf50\udf57\udf5d-\udf63\udf66-\udf6c\udf70-\udf74]|\ud805[\udc00-\udc4a\udc50-\udc59\udc5e-\udc5f\udc80-\udcc5\udcc7\udcd0-\udcd9\udd80-\uddb5\uddb8-\uddc0\uddd8-\udddd\ude00-\ude40\ude44\ude50-\ude59\ude80-\udeb8\udec0-\udec9\udf00-\udf1a\udf1d-\udf2b\udf30-\udf39]|\ud806[\udc00-\udc3a\udca0-\udce9\udcff\udda0-\udda7\uddaa-\uddd7\uddda-\udde1\udde3-\udde4\ude00-\ude3e\ude47\ude50-\ude99\ude9d\udec0-\udef8]|\ud807[\udc00-\udc08\udc0a-\udc36\udc38-\udc40\udc50-\udc59\udc72-\udc8f\udc92-\udca7\udca9-\udcb6\udd00-\udd06\udd08-\udd09\udd0b-\udd36\udd3a\udd3c-\udd3d\udd3f-\udd47\udd50-\udd59\udd60-\udd65\udd67-\udd68\udd6a-\udd8e\udd90-\udd91\udd93-\udd98\udda0-\udda9\udee0-\udef6]|\ud808[\udc00-\udf99]|\ud809[\udc00-\udc6e\udc80-\udd43]|\ud80c[\udc00-\udfff]|\ud80d[\udc00-\udc2e]|\ud811[\udc00-\ude46]|\ud81a[\udc00-\ude38\ude40-\ude5e\ude60-\ude69\uded0-\udeed\udef0-\udef4\udf00-\udf36\udf40-\udf43\udf50-\udf59\udf63-\udf77\udf7d-\udf8f]|\ud81b[\ude40-\ude7f\udf00-\udf4a\udf4f-\udf87\udf8f-\udf9f\udfe0-\udfe1\udfe3]|\ud81c[\udc00-\udfff]|\ud81d[\udc00-\udfff]|\ud81e[\udc00-\udfff]|\ud81f[\udc00-\udfff]|\ud820[\udc00-\udfff]|\ud821[\udc00-\udff7]|\ud822[\udc00-\udef2]|\ud82c[\udc00-\udd1e\udd50-\udd52\udd64-\udd67\udd70-\udefb]|\ud82f[\udc00-\udc6a\udc70-\udc7c\udc80-\udc88\udc90-\udc99\udc9d-\udc9e]|\ud834[\udd65-\udd69\udd6d-\udd72\udd7b-\udd82\udd85-\udd8b\uddaa-\uddad\ude42-\ude44]|\ud835[\udc00-\udc54\udc56-\udc9c\udc9e-\udc9f\udca2\udca5-\udca6\udca9-\udcac\udcae-\udcb9\udcbb\udcbd-\udcc3\udcc5-\udd05\udd07-\udd0a\udd0d-\udd14\udd16-\udd1c\udd1e-\udd39\udd3b-\udd3e\udd40-\udd44\udd46\udd4a-\udd50\udd52-\udea5\udea8-\udec0\udec2-\udeda\udedc-\udefa\udefc-\udf14\udf16-\udf34\udf36-\udf4e\udf50-\udf6e\udf70-\udf88\udf8a-\udfa8\udfaa-\udfc2\udfc4-\udfcb\udfce-\udfff]|\ud836[\ude00-\ude36\ude3b-\ude6c\ude75\ude84\ude9b-\ude9f\udea1-\udeaf]|\ud838[\udc00-\udc06\udc08-\udc18\udc1b-\udc21\udc23-\udc24\udc26-\udc2a\udd00-\udd2c\udd30-\udd3d\udd40-\udd49\udd4e\udec0-\udef9]|\ud83a[\udc00-\udcc4\udcd0-\udcd6\udd00-\udd4b\udd50-\udd59]|\ud83b[\ude00-\ude03\ude05-\ude1f\ude21-\ude22\ude24\ude27\ude29-\ude32\ude34-\ude37\ude39\ude3b\ude42\ude47\ude49\ude4b\ude4d-\ude4f\ude51-\ude52\ude54\ude57\ude59\ude5b\ude5d\ude5f\ude61-\ude62\ude64\ude67-\ude6a\ude6c-\ude72\ude74-\ude77\ude79-\ude7c\ude7e\ude80-\ude89\ude8b-\ude9b\udea1-\udea3\udea5-\udea9\udeab-\udebb]|\ud840[\udc00-\udfff]|\ud841[\udc00-\udfff]|\ud842[\udc00-\udfff]|\ud843[\udc00-\udfff]|\ud844[\udc00-\udfff]|\ud845[\udc00-\udfff]|\ud846[\udc00-\udfff]|\ud847[\udc00-\udfff]|\ud848[\udc00-\udfff]|\ud849[\udc00-\udfff]|\ud84a[\udc00-\udfff]|\ud84b[\udc00-\udfff]|\ud84c[\udc00-\udfff]|\ud84d[\udc00-\udfff]|\ud84e[\udc00-\udfff]|\ud84f[\udc00-\udfff]|\ud850[\udc00-\udfff]|\ud851[\udc00-\udfff]|\ud852[\udc00-\udfff]|\ud853[\udc00-\udfff]|\ud854[\udc00-\udfff]|\ud855[\udc00-\udfff]|\ud856[\udc00-\udfff]|\ud857[\udc00-\udfff]|\ud858[\udc00-\udfff]|\ud859[\udc00-\udfff]|\ud85a[\udc00-\udfff]|\ud85b[\udc00-\udfff]|\ud85c[\udc00-\udfff]|\ud85d[\udc00-\udfff]|\ud85e[\udc00-\udfff]|\ud85f[\udc00-\udfff]|\ud860[\udc00-\udfff]|\ud861[\udc00-\udfff]|\ud862[\udc00-\udfff]|\ud863[\udc00-\udfff]|\ud864[\udc00-\udfff]|\ud865[\udc00-\udfff]|\ud866[\udc00-\udfff]|\ud867[\udc00-\udfff]|\ud868[\udc00-\udfff]|\ud869[\udc00-\uded6\udf00-\udfff]|\ud86a[\udc00-\udfff]|\ud86b[\udc00-\udfff]|\ud86c[\udc00-\udfff]|\ud86d[\udc00-\udf34\udf40-\udfff]|\ud86e[\udc00-\udc1d\udc20-\udfff]|\ud86f[\udc00-\udfff]|\ud870[\udc00-\udfff]|\ud871[\udc00-\udfff]|\ud872[\udc00-\udfff]|\ud873[\udc00-\udea1\udeb0-\udfff]|\ud874[\udc00-\udfff]|\ud875[\udc00-\udfff]|\ud876[\udc00-\udfff]|\ud877[\udc00-\udfff]|\ud878[\udc00-\udfff]|\ud879[\udc00-\udfff]|\ud87a[\udc00-\udfe0]|\ud87e[\udc00-\ude1d]|\udb40[\udd00-\uddef])|[$_]|(\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]{1,}\})|[\u200c\u200d])*>/, function () {
|
|
yytext = yytext.slice(3, -1);
|
|
validateUnicodeGroupName(yytext, this.getCurrentState());
|
|
return 'NAMED_CAPTURE_GROUP';
|
|
}], [/^\(/, function () {
|
|
return 'L_PAREN';
|
|
}], [/^\)/, function () {
|
|
return 'R_PAREN';
|
|
}], [/^[*?+[^$]/, function () {
|
|
return 'CHAR';
|
|
}], [/^\\\]/, function () {
|
|
return 'ESC_CHAR';
|
|
}], [/^\]/, function () {
|
|
this.popState();return 'R_BRACKET';
|
|
}], [/^\^/, function () {
|
|
return 'BOS';
|
|
}], [/^\$/, function () {
|
|
return 'EOS';
|
|
}], [/^\*/, function () {
|
|
return 'STAR';
|
|
}], [/^\?/, function () {
|
|
return 'Q_MARK';
|
|
}], [/^\+/, function () {
|
|
return 'PLUS';
|
|
}], [/^\|/, function () {
|
|
return 'BAR';
|
|
}], [/^\./, function () {
|
|
return 'ANY';
|
|
}], [/^\//, function () {
|
|
return 'SLASH';
|
|
}], [/^[^*?+\[()\\|]/, function () {
|
|
return 'CHAR';
|
|
}], [/^\[\^/, function () {
|
|
var s = this.getCurrentState();this.pushState(s === 'u' || s === 'xu' ? 'u_class' : 'class');return 'NEG_CLASS';
|
|
}], [/^\[/, function () {
|
|
var s = this.getCurrentState();this.pushState(s === 'u' || s === 'xu' ? 'u_class' : 'class');return 'L_BRACKET';
|
|
}]];
|
|
var lexRulesByConditions = { "INITIAL": [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 22, 23, 24, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51], "u": [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51], "xu": [0, 1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51], "x": [0, 1, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 22, 23, 24, 26, 27, 30, 31, 32, 33, 34, 35, 36, 37, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51], "u_class": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51], "class": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20, 22, 23, 24, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51] };
|
|
|
|
var EOF_TOKEN = {
|
|
type: EOF,
|
|
value: ''
|
|
};
|
|
|
|
tokenizer = {
|
|
initString: function initString(string) {
|
|
this._string = string;
|
|
this._cursor = 0;
|
|
|
|
this._states = ['INITIAL'];
|
|
this._tokensQueue = [];
|
|
|
|
this._currentLine = 1;
|
|
this._currentColumn = 0;
|
|
this._currentLineBeginOffset = 0;
|
|
|
|
/**
|
|
* Matched token location data.
|
|
*/
|
|
this._tokenStartOffset = 0;
|
|
this._tokenEndOffset = 0;
|
|
this._tokenStartLine = 1;
|
|
this._tokenEndLine = 1;
|
|
this._tokenStartColumn = 0;
|
|
this._tokenEndColumn = 0;
|
|
|
|
return this;
|
|
},
|
|
|
|
|
|
/**
|
|
* Returns tokenizer states.
|
|
*/
|
|
getStates: function getStates() {
|
|
return this._states;
|
|
},
|
|
getCurrentState: function getCurrentState() {
|
|
return this._states[this._states.length - 1];
|
|
},
|
|
pushState: function pushState(state) {
|
|
this._states.push(state);
|
|
},
|
|
begin: function begin(state) {
|
|
this.pushState(state);
|
|
},
|
|
popState: function popState() {
|
|
if (this._states.length > 1) {
|
|
return this._states.pop();
|
|
}
|
|
return this._states[0];
|
|
},
|
|
getNextToken: function getNextToken() {
|
|
// Something was queued, return it.
|
|
if (this._tokensQueue.length > 0) {
|
|
return this.onToken(this._toToken(this._tokensQueue.shift()));
|
|
}
|
|
|
|
if (!this.hasMoreTokens()) {
|
|
return this.onToken(EOF_TOKEN);
|
|
}
|
|
|
|
var string = this._string.slice(this._cursor);
|
|
var lexRulesForState = lexRulesByConditions[this.getCurrentState()];
|
|
|
|
for (var i = 0; i < lexRulesForState.length; i++) {
|
|
var lexRuleIndex = lexRulesForState[i];
|
|
var lexRule = lexRules[lexRuleIndex];
|
|
|
|
var matched = this._match(string, lexRule[0]);
|
|
|
|
// Manual handling of EOF token (the end of string). Return it
|
|
// as `EOF` symbol.
|
|
if (string === '' && matched === '') {
|
|
this._cursor++;
|
|
}
|
|
|
|
if (matched !== null) {
|
|
yytext = matched;
|
|
yytext.length;
|
|
var token = lexRule[1].call(this);
|
|
|
|
if (!token) {
|
|
return this.getNextToken();
|
|
}
|
|
|
|
// If multiple tokens are returned, save them to return
|
|
// on next `getNextToken` call.
|
|
|
|
if (Array.isArray(token)) {
|
|
var tokensToQueue = token.slice(1);
|
|
token = token[0];
|
|
if (tokensToQueue.length > 0) {
|
|
var _tokensQueue;
|
|
|
|
(_tokensQueue = this._tokensQueue).unshift.apply(_tokensQueue, _toConsumableArray$8(tokensToQueue));
|
|
}
|
|
}
|
|
|
|
return this.onToken(this._toToken(token, yytext));
|
|
}
|
|
}
|
|
|
|
if (this.isEOF()) {
|
|
this._cursor++;
|
|
return EOF_TOKEN;
|
|
}
|
|
|
|
this.throwUnexpectedToken(string[0], this._currentLine, this._currentColumn);
|
|
},
|
|
|
|
|
|
/**
|
|
* Throws default "Unexpected token" exception, showing the actual
|
|
* line from the source, pointing with the ^ marker to the bad token.
|
|
* In addition, shows `line:column` location.
|
|
*/
|
|
throwUnexpectedToken: function throwUnexpectedToken(symbol, line, column) {
|
|
var lineSource = this._string.split('\n')[line - 1];
|
|
var lineData = '';
|
|
|
|
if (lineSource) {
|
|
var pad = ' '.repeat(column);
|
|
lineData = '\n\n' + lineSource + '\n' + pad + '^\n';
|
|
}
|
|
|
|
throw new SyntaxError(lineData + 'Unexpected token: "' + symbol + '" ' + ('at ' + line + ':' + column + '.'));
|
|
},
|
|
getCursor: function getCursor() {
|
|
return this._cursor;
|
|
},
|
|
getCurrentLine: function getCurrentLine() {
|
|
return this._currentLine;
|
|
},
|
|
getCurrentColumn: function getCurrentColumn() {
|
|
return this._currentColumn;
|
|
},
|
|
_captureLocation: function _captureLocation(matched) {
|
|
var nlRe = /\n/g;
|
|
|
|
// Absolute offsets.
|
|
this._tokenStartOffset = this._cursor;
|
|
|
|
// Line-based locations, start.
|
|
this._tokenStartLine = this._currentLine;
|
|
this._tokenStartColumn = this._tokenStartOffset - this._currentLineBeginOffset;
|
|
|
|
// Extract `\n` in the matched token.
|
|
var nlMatch = void 0;
|
|
while ((nlMatch = nlRe.exec(matched)) !== null) {
|
|
this._currentLine++;
|
|
this._currentLineBeginOffset = this._tokenStartOffset + nlMatch.index + 1;
|
|
}
|
|
|
|
this._tokenEndOffset = this._cursor + matched.length;
|
|
|
|
// Line-based locations, end.
|
|
this._tokenEndLine = this._currentLine;
|
|
this._tokenEndColumn = this._currentColumn = this._tokenEndOffset - this._currentLineBeginOffset;
|
|
},
|
|
_toToken: function _toToken(tokenType) {
|
|
var yytext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
|
|
|
|
return {
|
|
// Basic data.
|
|
type: tokenType,
|
|
value: yytext,
|
|
|
|
// Location data.
|
|
startOffset: this._tokenStartOffset,
|
|
endOffset: this._tokenEndOffset,
|
|
startLine: this._tokenStartLine,
|
|
endLine: this._tokenEndLine,
|
|
startColumn: this._tokenStartColumn,
|
|
endColumn: this._tokenEndColumn
|
|
};
|
|
},
|
|
isEOF: function isEOF() {
|
|
return this._cursor === this._string.length;
|
|
},
|
|
hasMoreTokens: function hasMoreTokens() {
|
|
return this._cursor <= this._string.length;
|
|
},
|
|
_match: function _match(string, regexp) {
|
|
var matched = string.match(regexp);
|
|
if (matched) {
|
|
// Handle `\n` in the matched token to track line numbers.
|
|
this._captureLocation(matched[0]);
|
|
this._cursor += matched[0].length;
|
|
return matched[0];
|
|
}
|
|
return null;
|
|
},
|
|
|
|
|
|
/**
|
|
* Allows analyzing, and transforming token. Default implementation
|
|
* just passes the token through.
|
|
*/
|
|
onToken: function onToken(token) {
|
|
return token;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Expose tokenizer so it can be accessed in semantic actions.
|
|
*/
|
|
yy.lexer = tokenizer;
|
|
yy.tokenizer = tokenizer;
|
|
|
|
/**
|
|
* Global parsing options. Some options can be shadowed per
|
|
* each `parse` call, if the optations are passed.
|
|
*
|
|
* Initalized to the `captureLocations` which is passed
|
|
* from the generator. Other options can be added at runtime.
|
|
*/
|
|
yy.options = {
|
|
captureLocations: true
|
|
};
|
|
|
|
/**
|
|
* Parsing module.
|
|
*/
|
|
var yyparse = {
|
|
/**
|
|
* Sets global parsing options.
|
|
*/
|
|
setOptions: function setOptions(options) {
|
|
yy.options = options;
|
|
return this;
|
|
},
|
|
|
|
|
|
/**
|
|
* Returns parsing options.
|
|
*/
|
|
getOptions: function getOptions() {
|
|
return yy.options;
|
|
},
|
|
|
|
|
|
/**
|
|
* Parses a string.
|
|
*/
|
|
parse: function parse(string, parseOptions) {
|
|
if (!tokenizer) {
|
|
throw new Error('Tokenizer instance wasn\'t specified.');
|
|
}
|
|
|
|
tokenizer.initString(string);
|
|
|
|
/**
|
|
* If parse options are passed, override global parse options for
|
|
* this call, and later restore global options.
|
|
*/
|
|
var globalOptions = yy.options;
|
|
if (parseOptions) {
|
|
yy.options = Object.assign({}, yy.options, parseOptions);
|
|
}
|
|
|
|
/**
|
|
* Allow callers to do setup work based on the
|
|
* parsing string, and passed options.
|
|
*/
|
|
yyparse.onParseBegin(string, tokenizer, yy.options);
|
|
|
|
stack.length = 0;
|
|
stack.push(0);
|
|
|
|
var token = tokenizer.getNextToken();
|
|
var shiftedToken = null;
|
|
|
|
do {
|
|
if (!token) {
|
|
// Restore options.
|
|
yy.options = globalOptions;
|
|
unexpectedEndOfInput();
|
|
}
|
|
|
|
var state = stack[stack.length - 1];
|
|
var column = tokens[token.type];
|
|
|
|
if (!table[state].hasOwnProperty(column)) {
|
|
yy.options = globalOptions;
|
|
unexpectedToken(token);
|
|
}
|
|
|
|
var entry = table[state][column];
|
|
|
|
// Shift action.
|
|
if (entry[0] === 's') {
|
|
var _loc2 = null;
|
|
|
|
if (yy.options.captureLocations) {
|
|
_loc2 = {
|
|
startOffset: token.startOffset,
|
|
endOffset: token.endOffset,
|
|
startLine: token.startLine,
|
|
endLine: token.endLine,
|
|
startColumn: token.startColumn,
|
|
endColumn: token.endColumn
|
|
};
|
|
}
|
|
|
|
shiftedToken = this.onShift(token);
|
|
|
|
stack.push({ symbol: tokens[shiftedToken.type], semanticValue: shiftedToken.value, loc: _loc2 }, Number(entry.slice(1)));
|
|
|
|
token = tokenizer.getNextToken();
|
|
}
|
|
|
|
// Reduce action.
|
|
else if (entry[0] === 'r') {
|
|
var productionNumber = entry.slice(1);
|
|
var production = productions[productionNumber];
|
|
var hasSemanticAction = typeof production[2] === 'function';
|
|
var semanticValueArgs = hasSemanticAction ? [] : null;
|
|
|
|
var locationArgs = hasSemanticAction && yy.options.captureLocations ? [] : null;
|
|
|
|
if (production[1] !== 0) {
|
|
var rhsLength = production[1];
|
|
while (rhsLength-- > 0) {
|
|
stack.pop();
|
|
var stackEntry = stack.pop();
|
|
|
|
if (hasSemanticAction) {
|
|
semanticValueArgs.unshift(stackEntry.semanticValue);
|
|
|
|
if (locationArgs) {
|
|
locationArgs.unshift(stackEntry.loc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var reduceStackEntry = { symbol: production[0] };
|
|
|
|
if (hasSemanticAction) {
|
|
yytext = shiftedToken ? shiftedToken.value : null;
|
|
shiftedToken ? shiftedToken.value.length : null;
|
|
|
|
var semanticActionArgs = locationArgs !== null ? semanticValueArgs.concat(locationArgs) : semanticValueArgs;
|
|
|
|
production[2].apply(production, _toConsumableArray$8(semanticActionArgs));
|
|
|
|
reduceStackEntry.semanticValue = __;
|
|
|
|
if (locationArgs) {
|
|
reduceStackEntry.loc = __loc;
|
|
}
|
|
}
|
|
|
|
var nextState = stack[stack.length - 1];
|
|
var symbolToReduceWith = production[0];
|
|
|
|
stack.push(reduceStackEntry, table[nextState][symbolToReduceWith]);
|
|
}
|
|
|
|
// Accept.
|
|
else if (entry === 'acc') {
|
|
stack.pop();
|
|
var parsed = stack.pop();
|
|
|
|
if (stack.length !== 1 || stack[0] !== 0 || tokenizer.hasMoreTokens()) {
|
|
// Restore options.
|
|
yy.options = globalOptions;
|
|
unexpectedToken(token);
|
|
}
|
|
|
|
if (parsed.hasOwnProperty('semanticValue')) {
|
|
yy.options = globalOptions;
|
|
yyparse.onParseEnd(parsed.semanticValue);
|
|
return parsed.semanticValue;
|
|
}
|
|
|
|
yyparse.onParseEnd();
|
|
|
|
// Restore options.
|
|
yy.options = globalOptions;
|
|
return true;
|
|
}
|
|
} while (tokenizer.hasMoreTokens() || stack.length > 1);
|
|
},
|
|
setTokenizer: function setTokenizer(customTokenizer) {
|
|
tokenizer = customTokenizer;
|
|
return yyparse;
|
|
},
|
|
getTokenizer: function getTokenizer() {
|
|
return tokenizer;
|
|
},
|
|
onParseBegin: function onParseBegin(string, tokenizer, options) {},
|
|
onParseEnd: function onParseEnd(parsed) {},
|
|
|
|
|
|
/**
|
|
* Allows analyzing, and transforming shifted token. Default implementation
|
|
* just passes the token through.
|
|
*/
|
|
onShift: function onShift(token) {
|
|
return token;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Tracks capturing groups.
|
|
*/
|
|
var capturingGroupsCount = 0;
|
|
|
|
/**
|
|
* Tracks named groups.
|
|
*/
|
|
var namedGroups = {};
|
|
|
|
/**
|
|
* Parsing string.
|
|
*/
|
|
var parsingString = '';
|
|
|
|
yyparse.onParseBegin = function (string, lexer) {
|
|
parsingString = string;
|
|
capturingGroupsCount = 0;
|
|
namedGroups = {};
|
|
|
|
var lastSlash = string.lastIndexOf('/');
|
|
var flags = string.slice(lastSlash);
|
|
|
|
if (flags.includes('x') && flags.includes('u')) {
|
|
lexer.pushState('xu');
|
|
} else {
|
|
if (flags.includes('x')) {
|
|
lexer.pushState('x');
|
|
}
|
|
if (flags.includes('u')) {
|
|
lexer.pushState('u');
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* On shifting `(` remember its number to used on reduce.
|
|
*/
|
|
yyparse.onShift = function (token) {
|
|
if (token.type === 'L_PAREN' || token.type === 'NAMED_CAPTURE_GROUP') {
|
|
token.value = new String(token.value);
|
|
token.value.groupNumber = ++capturingGroupsCount;
|
|
}
|
|
return token;
|
|
};
|
|
|
|
/**
|
|
* Extracts ranges from the range string.
|
|
*/
|
|
function getRange(text) {
|
|
var range = text.match(/\d+/g).map(Number);
|
|
|
|
if (Number.isFinite(range[1]) && range[1] < range[0]) {
|
|
throw new SyntaxError('Numbers out of order in ' + text + ' quantifier');
|
|
}
|
|
|
|
return range;
|
|
}
|
|
|
|
/**
|
|
* Checks class range
|
|
*/
|
|
function checkClassRange(from, to) {
|
|
if (from.kind === 'control' || to.kind === 'control' || !isNaN(from.codePoint) && !isNaN(to.codePoint) && from.codePoint > to.codePoint) {
|
|
throw new SyntaxError('Range ' + from.value + '-' + to.value + ' out of order in character class');
|
|
}
|
|
}
|
|
|
|
// ---------------------- Unicode property -------------------------------------------
|
|
|
|
var unicodeProperties = parserUnicodeProperties;
|
|
|
|
/**
|
|
* Unicode property.
|
|
*/
|
|
function UnicodeProperty(matched, loc) {
|
|
var negative = matched[1] === 'P';
|
|
var separatorIdx = matched.indexOf('=');
|
|
|
|
var name = matched.slice(3, separatorIdx !== -1 ? separatorIdx : -1);
|
|
var value = void 0;
|
|
|
|
// General_Category allows using only value as a shorthand.
|
|
var isShorthand = separatorIdx === -1 && unicodeProperties.isGeneralCategoryValue(name);
|
|
|
|
// Binary propery name.
|
|
var isBinaryProperty = separatorIdx === -1 && unicodeProperties.isBinaryPropertyName(name);
|
|
|
|
if (isShorthand) {
|
|
value = name;
|
|
name = 'General_Category';
|
|
} else if (isBinaryProperty) {
|
|
value = name;
|
|
} else {
|
|
if (!unicodeProperties.isValidName(name)) {
|
|
throw new SyntaxError('Invalid unicode property name: ' + name + '.');
|
|
}
|
|
|
|
value = matched.slice(separatorIdx + 1, -1);
|
|
|
|
if (!unicodeProperties.isValidValue(name, value)) {
|
|
throw new SyntaxError('Invalid ' + name + ' unicode property value: ' + value + '.');
|
|
}
|
|
}
|
|
|
|
return Node({
|
|
type: 'UnicodeProperty',
|
|
name: name,
|
|
value: value,
|
|
negative: negative,
|
|
shorthand: isShorthand,
|
|
binary: isBinaryProperty,
|
|
canonicalName: unicodeProperties.getCanonicalName(name) || name,
|
|
canonicalValue: unicodeProperties.getCanonicalValue(value) || value
|
|
}, loc);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
|
|
|
|
/**
|
|
* Creates a character node.
|
|
*/
|
|
function Char(value, kind, loc) {
|
|
var symbol = void 0;
|
|
var codePoint = void 0;
|
|
|
|
switch (kind) {
|
|
case 'decimal':
|
|
{
|
|
codePoint = Number(value.slice(1));
|
|
symbol = String.fromCodePoint(codePoint);
|
|
break;
|
|
}
|
|
case 'oct':
|
|
{
|
|
codePoint = parseInt(value.slice(1), 8);
|
|
symbol = String.fromCodePoint(codePoint);
|
|
break;
|
|
}
|
|
case 'hex':
|
|
case 'unicode':
|
|
{
|
|
if (value.lastIndexOf('\\u') > 0) {
|
|
var _value$split$slice = value.split('\\u').slice(1),
|
|
_value$split$slice2 = _slicedToArray$2(_value$split$slice, 2),
|
|
lead = _value$split$slice2[0],
|
|
trail = _value$split$slice2[1];
|
|
|
|
lead = parseInt(lead, 16);
|
|
trail = parseInt(trail, 16);
|
|
codePoint = (lead - 0xd800) * 0x400 + (trail - 0xdc00) + 0x10000;
|
|
|
|
symbol = String.fromCodePoint(codePoint);
|
|
} else {
|
|
var hex = value.slice(2).replace('{', '');
|
|
codePoint = parseInt(hex, 16);
|
|
if (codePoint > 0x10ffff) {
|
|
throw new SyntaxError('Bad character escape sequence: ' + value);
|
|
}
|
|
|
|
symbol = String.fromCodePoint(codePoint);
|
|
}
|
|
break;
|
|
}
|
|
case 'meta':
|
|
{
|
|
switch (value) {
|
|
case '\\t':
|
|
symbol = '\t';
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
case '\\n':
|
|
symbol = '\n';
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
case '\\r':
|
|
symbol = '\r';
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
case '\\v':
|
|
symbol = '\v';
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
case '\\f':
|
|
symbol = '\f';
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
case '\\b':
|
|
symbol = '\b';
|
|
codePoint = symbol.codePointAt(0);
|
|
case '\\0':
|
|
symbol = '\0';
|
|
codePoint = 0;
|
|
case '.':
|
|
symbol = '.';
|
|
codePoint = NaN;
|
|
break;
|
|
default:
|
|
codePoint = NaN;
|
|
}
|
|
break;
|
|
}
|
|
case 'simple':
|
|
{
|
|
symbol = value;
|
|
codePoint = symbol.codePointAt(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return Node({
|
|
type: 'Char',
|
|
value: value,
|
|
kind: kind,
|
|
symbol: symbol,
|
|
codePoint: codePoint
|
|
}, loc);
|
|
}
|
|
|
|
/**
|
|
* Valid flags per current ECMAScript spec and
|
|
* stage 3+ proposals.
|
|
*/
|
|
var validFlags = 'gimsuxy';
|
|
|
|
/**
|
|
* Checks the flags are valid, and that
|
|
* we don't duplicate flags.
|
|
*/
|
|
function checkFlags(flags) {
|
|
var seen = new Set();
|
|
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = flags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var flag = _step.value;
|
|
|
|
if (seen.has(flag) || !validFlags.includes(flag)) {
|
|
throw new SyntaxError('Invalid flags: ' + flags);
|
|
}
|
|
seen.add(flag);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
|
|
return flags.split('').sort().join('');
|
|
}
|
|
|
|
/**
|
|
* Parses patterns like \1, \2, etc. either as a backreference
|
|
* to a group, or a deciaml char code.
|
|
*/
|
|
function GroupRefOrDecChar(text, textLoc) {
|
|
var reference = Number(text.slice(1));
|
|
|
|
if (reference > 0 && reference <= capturingGroupsCount) {
|
|
return Node({
|
|
type: 'Backreference',
|
|
kind: 'number',
|
|
number: reference,
|
|
reference: reference
|
|
}, textLoc);
|
|
}
|
|
|
|
return Char(text, 'decimal', textLoc);
|
|
}
|
|
|
|
/**
|
|
* Unicode names.
|
|
*/
|
|
var uReStart = /^\\u[0-9a-fA-F]{4}/; // only matches start of string
|
|
var ucpReStart = /^\\u\{[0-9a-fA-F]{1,}\}/; // only matches start of string
|
|
var ucpReAnywhere = /\\u\{[0-9a-fA-F]{1,}\}/; // matches anywhere in string
|
|
|
|
/**
|
|
* Validates Unicode group name.
|
|
*/
|
|
function validateUnicodeGroupName(name, state) {
|
|
var isUnicodeName = ucpReAnywhere.test(name);
|
|
var isUnicodeState = state === 'u' || state === 'xu' || state === 'u_class';
|
|
|
|
if (isUnicodeName && !isUnicodeState) {
|
|
throw new SyntaxError('invalid group Unicode name "' + name + '", use `u` flag.');
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
// Matches the following production: https://tc39.es/ecma262/#prod-RegExpUnicodeEscapeSequence
|
|
//
|
|
// RegExpUnicodeEscapeSequence ::
|
|
// `u` LeadSurrogate `\u` TrailSurrogate # as 'leadSurrogate', 'trailSurrogate'
|
|
// `u` LeadSurrogate # as 'leadSurrogateOnly'
|
|
// `u` TrailSurrogate # as 'trailSurrogateOnly'
|
|
// `u` NonSurrogate # as 'nonSurrogate'
|
|
// `u` `{` CodePoint `}` # as 'codePoint'
|
|
//
|
|
// LeadSurrogate ::
|
|
// Hex4Digits but only if the SV of Hex4Digits is in the inclusive range 0xD800 to 0xDBFF # [dD][89aAbB][0-9a-fA-F]{2}
|
|
//
|
|
// TrailSurrogate ::
|
|
// Hex4Digits but only if the SV of Hex4Digits is in the inclusive range 0xDC00 to 0xDFFF # [dD][c-fC-F][0-9a-fA-F]{2}
|
|
//
|
|
// NonSurrogate ::
|
|
// Hex4Digits but only if the SV of Hex4Digits is not in the inclusive range 0xD800 to 0xDFFF # [0-9a-ce-fA-CE-F][0-9a-fA-F]{3}|[dD][0-7][0-9a-fA-F]{2}
|
|
//
|
|
// CodePoint ::
|
|
// HexDigits but only if MV of HexDigits ≤ 0x10FFFF # 0*(?:[0-9a-fA-F]{1,5}|10[0-9a-fA-F]{4})
|
|
//
|
|
var uidRe = /\\u(?:([dD][89aAbB][0-9a-fA-F]{2})\\u([dD][c-fC-F][0-9a-fA-F]{2})|([dD][89aAbB][0-9a-fA-F]{2})|([dD][c-fC-F][0-9a-fA-F]{2})|([0-9a-ce-fA-CE-F][0-9a-fA-F]{3}|[dD][0-7][0-9a-fA-F]{2})|\{(0*(?:[0-9a-fA-F]{1,5}|10[0-9a-fA-F]{4}))\})/;
|
|
|
|
function decodeUnicodeGroupName(name) {
|
|
return name.replace(new RegExp(uidRe, 'g'), function (_, leadSurrogate, trailSurrogate, leadSurrogateOnly, trailSurrogateOnly, nonSurrogate, codePoint) {
|
|
if (leadSurrogate) {
|
|
return String.fromCodePoint(parseInt(leadSurrogate, 16), parseInt(trailSurrogate, 16));
|
|
}
|
|
if (leadSurrogateOnly) {
|
|
return String.fromCodePoint(parseInt(leadSurrogateOnly, 16));
|
|
}
|
|
if (trailSurrogateOnly) {
|
|
// TODO: Per the spec: https://tc39.es/ecma262/#prod-RegExpUnicodeEscapeSequence
|
|
// > Each `\u` TrailSurrogate for which the choice of associated `u` LeadSurrogate is ambiguous shall be associated with the nearest possible `u` LeadSurrogate that would otherwise have no corresponding `\u` TrailSurrogate.
|
|
return String.fromCodePoint(parseInt(trailSurrogateOnly, 16));
|
|
}
|
|
if (nonSurrogate) {
|
|
return String.fromCodePoint(parseInt(nonSurrogate, 16));
|
|
}
|
|
if (codePoint) {
|
|
return String.fromCodePoint(parseInt(codePoint, 16));
|
|
}
|
|
return _;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Extracts from `\k<foo>` pattern either a backreference
|
|
* to a named capturing group (if it presents), or parses it
|
|
* as a list of char: `\k`, `<`, `f`, etc.
|
|
*/
|
|
function NamedGroupRefOrChars(text, textLoc) {
|
|
var referenceRaw = text.slice(3, -1);
|
|
var reference = decodeUnicodeGroupName(referenceRaw);
|
|
|
|
if (namedGroups.hasOwnProperty(reference)) {
|
|
return Node({
|
|
type: 'Backreference',
|
|
kind: 'name',
|
|
number: namedGroups[reference],
|
|
reference: reference,
|
|
referenceRaw: referenceRaw
|
|
}, textLoc);
|
|
}
|
|
|
|
// Else `\k<foo>` should be parsed as a list of `Char`s.
|
|
// This is really a 0.01% edge case, but we should handle it.
|
|
|
|
var startOffset = null;
|
|
var startLine = null;
|
|
var endLine = null;
|
|
var startColumn = null;
|
|
|
|
if (textLoc) {
|
|
startOffset = textLoc.startOffset;
|
|
startLine = textLoc.startLine;
|
|
endLine = textLoc.endLine;
|
|
startColumn = textLoc.startColumn;
|
|
}
|
|
|
|
var charRe = /^[\w$<>]/;
|
|
var loc = void 0;
|
|
|
|
var chars = [
|
|
// Init to first \k, taking 2 symbols.
|
|
Char(text.slice(1, 2), 'simple', startOffset ? {
|
|
startLine: startLine,
|
|
endLine: endLine,
|
|
startColumn: startColumn,
|
|
startOffset: startOffset,
|
|
endOffset: startOffset += 2,
|
|
endColumn: startColumn += 2
|
|
} : null)];
|
|
|
|
// For \k
|
|
chars[0].escaped = true;
|
|
|
|
// Other symbols.
|
|
text = text.slice(2);
|
|
|
|
while (text.length > 0) {
|
|
var matched = null;
|
|
|
|
// Unicode, \u003B or \u{003B}
|
|
if ((matched = text.match(uReStart)) || (matched = text.match(ucpReStart))) {
|
|
if (startOffset) {
|
|
loc = {
|
|
startLine: startLine,
|
|
endLine: endLine,
|
|
startColumn: startColumn,
|
|
startOffset: startOffset,
|
|
endOffset: startOffset += matched[0].length,
|
|
endColumn: startColumn += matched[0].length
|
|
};
|
|
}
|
|
chars.push(Char(matched[0], 'unicode', loc));
|
|
text = text.slice(matched[0].length);
|
|
}
|
|
|
|
// Simple char.
|
|
else if (matched = text.match(charRe)) {
|
|
if (startOffset) {
|
|
loc = {
|
|
startLine: startLine,
|
|
endLine: endLine,
|
|
startColumn: startColumn,
|
|
startOffset: startOffset,
|
|
endOffset: ++startOffset,
|
|
endColumn: ++startColumn
|
|
};
|
|
}
|
|
chars.push(Char(matched[0], 'simple', loc));
|
|
text = text.slice(1);
|
|
}
|
|
}
|
|
|
|
return chars;
|
|
}
|
|
|
|
/**
|
|
* Creates an AST node with a location.
|
|
*/
|
|
function Node(node, loc) {
|
|
if (yy.options.captureLocations) {
|
|
node.loc = {
|
|
source: parsingString.slice(loc.startOffset, loc.endOffset),
|
|
start: {
|
|
line: loc.startLine,
|
|
column: loc.startColumn,
|
|
offset: loc.startOffset
|
|
},
|
|
end: {
|
|
line: loc.endLine,
|
|
column: loc.endColumn,
|
|
offset: loc.endOffset
|
|
}
|
|
};
|
|
}
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Creates location node.
|
|
*/
|
|
function loc(start, end) {
|
|
if (!yy.options.captureLocations) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
startOffset: start.startOffset,
|
|
endOffset: end.endOffset,
|
|
startLine: start.startLine,
|
|
endLine: end.endLine,
|
|
startColumn: start.startColumn,
|
|
endColumn: end.endColumn
|
|
};
|
|
}
|
|
|
|
function unexpectedToken(token) {
|
|
if (token.type === EOF) {
|
|
unexpectedEndOfInput();
|
|
}
|
|
|
|
tokenizer.throwUnexpectedToken(token.value, token.startLine, token.startColumn);
|
|
}
|
|
|
|
function unexpectedEndOfInput() {
|
|
parseError('Unexpected end of input.');
|
|
}
|
|
|
|
function parseError(message) {
|
|
throw new SyntaxError(message);
|
|
}
|
|
|
|
var regexpTree$4 = yyparse;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var regexpTreeParser = regexpTree$4;
|
|
|
|
/**
|
|
* Original parse function.
|
|
*/
|
|
var generatedParseFn = regexpTreeParser.parse.bind(regexpTreeParser);
|
|
|
|
/**
|
|
* Parses a regular expression.
|
|
*
|
|
* Override original `regexpTreeParser.parse` to convert a value to a string,
|
|
* since in regexp-tree we may pass strings, and RegExp instance.
|
|
*/
|
|
regexpTreeParser.parse = function (regexp, options) {
|
|
return generatedParseFn('' + regexp, options);
|
|
};
|
|
|
|
// By default do not capture locations; callers may override.
|
|
regexpTreeParser.setOptions({ captureLocations: false });
|
|
|
|
var parser$4 = regexpTreeParser;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _createClass$6 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var DEFAULT_COLLECTION_PROP = 'expressions';
|
|
var DEFAULT_SINGLE_PROP = 'expression';
|
|
|
|
/**
|
|
* NodePath class encapsulates a traversing node,
|
|
* its parent node, property name in the parent node, and
|
|
* an index (in case if a node is part of a collection).
|
|
* It also provides set of methods for AST manipulation.
|
|
*/
|
|
|
|
var NodePath$3 = function () {
|
|
/**
|
|
* NodePath constructor.
|
|
*
|
|
* @param Object node - an AST node
|
|
* @param NodePath parentPath - a nullable parent path
|
|
* @param string property - property name of the node in the parent
|
|
* @param number index - index of the node in a collection.
|
|
*/
|
|
function NodePath(node) {
|
|
var parentPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
var property = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
|
|
|
|
_classCallCheck$6(this, NodePath);
|
|
|
|
this.node = node;
|
|
this.parentPath = parentPath;
|
|
this.parent = parentPath ? parentPath.node : null;
|
|
this.property = property;
|
|
this.index = index;
|
|
}
|
|
|
|
_createClass$6(NodePath, [{
|
|
key: '_enforceProp',
|
|
value: function _enforceProp(property) {
|
|
if (!this.node.hasOwnProperty(property)) {
|
|
throw new Error('Node of type ' + this.node.type + ' doesn\'t have "' + property + '" collection.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets a node into a children collection or the single child.
|
|
* By default child nodes are supposed to be under `expressions` property.
|
|
* An explicit property can be passed.
|
|
*
|
|
* @param Object node - a node to set into a collection or as single child
|
|
* @param number index - index at which to set
|
|
* @param string property - name of the collection or single property
|
|
*/
|
|
|
|
}, {
|
|
key: 'setChild',
|
|
value: function setChild(node) {
|
|
var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
var property = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
|
|
|
|
var childPath = void 0;
|
|
if (index != null) {
|
|
if (!property) {
|
|
property = DEFAULT_COLLECTION_PROP;
|
|
}
|
|
this._enforceProp(property);
|
|
this.node[property][index] = node;
|
|
childPath = NodePath.getForNode(node, this, property, index);
|
|
} else {
|
|
if (!property) {
|
|
property = DEFAULT_SINGLE_PROP;
|
|
}
|
|
this._enforceProp(property);
|
|
this.node[property] = node;
|
|
childPath = NodePath.getForNode(node, this, property, null);
|
|
}
|
|
return childPath;
|
|
}
|
|
|
|
/**
|
|
* Appends a node to a children collection.
|
|
* By default child nodes are supposed to be under `expressions` property.
|
|
* An explicit property can be passed.
|
|
*
|
|
* @param Object node - a node to set into a collection or as single child
|
|
* @param string property - name of the collection or single property
|
|
*/
|
|
|
|
}, {
|
|
key: 'appendChild',
|
|
value: function appendChild(node) {
|
|
var property = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
|
|
|
|
if (!property) {
|
|
property = DEFAULT_COLLECTION_PROP;
|
|
}
|
|
this._enforceProp(property);
|
|
var end = this.node[property].length;
|
|
return this.setChild(node, end, property);
|
|
}
|
|
|
|
/**
|
|
* Inserts a node into a collection.
|
|
* By default child nodes are supposed to be under `expressions` property.
|
|
* An explicit property can be passed.
|
|
*
|
|
* @param Object node - a node to insert into a collection
|
|
* @param number index - index at which to insert
|
|
* @param string property - name of the collection property
|
|
*/
|
|
|
|
}, {
|
|
key: 'insertChildAt',
|
|
value: function insertChildAt(node, index) {
|
|
var property = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_COLLECTION_PROP;
|
|
|
|
this._enforceProp(property);
|
|
|
|
this.node[property].splice(index, 0, node);
|
|
|
|
// If we inserted a node before the traversing index,
|
|
// we should increase the later.
|
|
if (index <= NodePath.getTraversingIndex()) {
|
|
NodePath.updateTraversingIndex(+1);
|
|
}
|
|
|
|
this._rebuildIndex(this.node, property);
|
|
}
|
|
|
|
/**
|
|
* Removes a node.
|
|
*/
|
|
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove() {
|
|
if (this.isRemoved()) {
|
|
return;
|
|
}
|
|
NodePath.registry.delete(this.node);
|
|
|
|
this.node = null;
|
|
|
|
if (!this.parent) {
|
|
return;
|
|
}
|
|
|
|
// A node is in a collection.
|
|
if (this.index !== null) {
|
|
this.parent[this.property].splice(this.index, 1);
|
|
|
|
// If we remove a node before the traversing index,
|
|
// we should increase the later.
|
|
if (this.index <= NodePath.getTraversingIndex()) {
|
|
NodePath.updateTraversingIndex(-1);
|
|
}
|
|
|
|
// Rebuild index.
|
|
this._rebuildIndex(this.parent, this.property);
|
|
|
|
this.index = null;
|
|
this.property = null;
|
|
|
|
return;
|
|
}
|
|
|
|
// A simple node.
|
|
delete this.parent[this.property];
|
|
this.property = null;
|
|
}
|
|
|
|
/**
|
|
* Rebuilds child nodes index (used on remove/insert).
|
|
*/
|
|
|
|
}, {
|
|
key: '_rebuildIndex',
|
|
value: function _rebuildIndex(parent, property) {
|
|
var parentPath = NodePath.getForNode(parent);
|
|
|
|
for (var i = 0; i < parent[property].length; i++) {
|
|
var path = NodePath.getForNode(parent[property][i], parentPath, property, i);
|
|
path.index = i;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Whether the path was removed.
|
|
*/
|
|
|
|
}, {
|
|
key: 'isRemoved',
|
|
value: function isRemoved() {
|
|
return this.node === null;
|
|
}
|
|
|
|
/**
|
|
* Replaces a node with the passed one.
|
|
*/
|
|
|
|
}, {
|
|
key: 'replace',
|
|
value: function replace(newNode) {
|
|
NodePath.registry.delete(this.node);
|
|
|
|
this.node = newNode;
|
|
|
|
if (!this.parent) {
|
|
return null;
|
|
}
|
|
|
|
// A node is in a collection.
|
|
if (this.index !== null) {
|
|
this.parent[this.property][this.index] = newNode;
|
|
}
|
|
|
|
// A simple node.
|
|
else {
|
|
this.parent[this.property] = newNode;
|
|
}
|
|
|
|
// Rebuild the node path for the new node.
|
|
return NodePath.getForNode(newNode, this.parentPath, this.property, this.index);
|
|
}
|
|
|
|
/**
|
|
* Updates a node inline.
|
|
*/
|
|
|
|
}, {
|
|
key: 'update',
|
|
value: function update(nodeProps) {
|
|
Object.assign(this.node, nodeProps);
|
|
}
|
|
|
|
/**
|
|
* Returns parent.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getParent',
|
|
value: function getParent() {
|
|
return this.parentPath;
|
|
}
|
|
|
|
/**
|
|
* Returns nth child.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getChild',
|
|
value: function getChild() {
|
|
var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
|
|
|
|
if (this.node.expressions) {
|
|
return NodePath.getForNode(this.node.expressions[n], this, DEFAULT_COLLECTION_PROP, n);
|
|
} else if (this.node.expression && n == 0) {
|
|
return NodePath.getForNode(this.node.expression, this, DEFAULT_SINGLE_PROP);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Whether a path node is syntactically equal to the passed one.
|
|
*
|
|
* NOTE: we don't rely on `source` property from the `loc` data
|
|
* (which would be the fastest comparison), since it might be unsync
|
|
* after several modifications. We use here simple `JSON.stringify`
|
|
* excluding the `loc` data.
|
|
*
|
|
* @param NodePath other - path to compare to.
|
|
* @return boolean
|
|
*/
|
|
|
|
}, {
|
|
key: 'hasEqualSource',
|
|
value: function hasEqualSource(path) {
|
|
return JSON.stringify(this.node, jsonSkipLoc) === JSON.stringify(path.node, jsonSkipLoc);
|
|
}
|
|
|
|
/**
|
|
* JSON-encodes a node skipping location.
|
|
*/
|
|
|
|
}, {
|
|
key: 'jsonEncode',
|
|
value: function jsonEncode() {
|
|
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
|
|
format = _ref.format,
|
|
useLoc = _ref.useLoc;
|
|
|
|
return JSON.stringify(this.node, useLoc ? null : jsonSkipLoc, format);
|
|
}
|
|
|
|
/**
|
|
* Returns previous sibling.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getPreviousSibling',
|
|
value: function getPreviousSibling() {
|
|
if (!this.parent || this.index == null) {
|
|
return null;
|
|
}
|
|
return NodePath.getForNode(this.parent[this.property][this.index - 1], NodePath.getForNode(this.parent), this.property, this.index - 1);
|
|
}
|
|
|
|
/**
|
|
* Returns next sibling.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getNextSibling',
|
|
value: function getNextSibling() {
|
|
if (!this.parent || this.index == null) {
|
|
return null;
|
|
}
|
|
return NodePath.getForNode(this.parent[this.property][this.index + 1], NodePath.getForNode(this.parent), this.property, this.index + 1);
|
|
}
|
|
|
|
/**
|
|
* Returns a NodePath instance for a node.
|
|
*
|
|
* The same NodePath can be reused in several places, e.g.
|
|
* a parent node passed for all its children.
|
|
*/
|
|
|
|
}], [{
|
|
key: 'getForNode',
|
|
value: function getForNode(node) {
|
|
var parentPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
var prop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
|
|
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
|
|
if (!NodePath.registry.has(node)) {
|
|
NodePath.registry.set(node, new NodePath(node, parentPath, prop, index == -1 ? null : index));
|
|
}
|
|
|
|
var path = NodePath.registry.get(node);
|
|
|
|
if (parentPath !== null) {
|
|
path.parentPath = parentPath;
|
|
path.parent = path.parentPath.node;
|
|
}
|
|
|
|
if (prop !== null) {
|
|
path.property = prop;
|
|
}
|
|
|
|
if (index >= 0) {
|
|
path.index = index;
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* Initializes the NodePath registry. The registry is a map from
|
|
* a node to its NodePath instance.
|
|
*/
|
|
|
|
}, {
|
|
key: 'initRegistry',
|
|
value: function initRegistry() {
|
|
if (!NodePath.registry) {
|
|
NodePath.registry = new Map();
|
|
}
|
|
NodePath.registry.clear();
|
|
}
|
|
|
|
/**
|
|
* Updates index of a currently traversing collection.
|
|
*/
|
|
|
|
}, {
|
|
key: 'updateTraversingIndex',
|
|
value: function updateTraversingIndex(dx) {
|
|
return NodePath.traversingIndexStack[NodePath.traversingIndexStack.length - 1] += dx;
|
|
}
|
|
|
|
/**
|
|
* Returns current traversing index.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getTraversingIndex',
|
|
value: function getTraversingIndex() {
|
|
return NodePath.traversingIndexStack[NodePath.traversingIndexStack.length - 1];
|
|
}
|
|
}]);
|
|
|
|
return NodePath;
|
|
}();
|
|
|
|
NodePath$3.initRegistry();
|
|
|
|
/**
|
|
* Index of a currently traversing collection is stored on top of the
|
|
* `NodePath.traversingIndexStack`. Remove/insert methods can adjust
|
|
* this index.
|
|
*/
|
|
NodePath$3.traversingIndexStack = [];
|
|
|
|
// Helper function used to skip `loc` in JSON operations.
|
|
function jsonSkipLoc(prop, value) {
|
|
if (prop === 'loc') {
|
|
return undefined;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
var nodePath = NodePath$3;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var NodePath$2 = nodePath;
|
|
|
|
/**
|
|
* Does an actual AST traversal, using visitor pattern,
|
|
* and calling set of callbacks.
|
|
*
|
|
* Based on https://github.com/olov/ast-traverse
|
|
*
|
|
* Expects AST in Mozilla Parser API: nodes which are supposed to be
|
|
* handled should have `type` property.
|
|
*
|
|
* @param Object root - a root node to start traversal from.
|
|
*
|
|
* @param Object options - an object with set of callbacks:
|
|
*
|
|
* - `pre(node, parent, prop, index)` - a hook called on node enter
|
|
* - `post`(node, parent, prop, index) - a hook called on node exit
|
|
* - `skipProperty(prop)` - a predicated whether a property should be skipped
|
|
*/
|
|
function astTraverse(root) {
|
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
var pre = options.pre;
|
|
var post = options.post;
|
|
var skipProperty = options.skipProperty;
|
|
|
|
function visit(node, parent, prop, idx) {
|
|
if (!node || typeof node.type !== 'string') {
|
|
return;
|
|
}
|
|
|
|
var res = undefined;
|
|
if (pre) {
|
|
res = pre(node, parent, prop, idx);
|
|
}
|
|
|
|
if (res !== false) {
|
|
|
|
// A node can be replaced during traversal, so we have to
|
|
// recalculate it from the parent, to avoid traversing "dead" nodes.
|
|
if (parent && parent[prop]) {
|
|
if (!isNaN(idx)) {
|
|
node = parent[prop][idx];
|
|
} else {
|
|
node = parent[prop];
|
|
}
|
|
}
|
|
|
|
for (var _prop in node) {
|
|
if (node.hasOwnProperty(_prop)) {
|
|
if (skipProperty ? skipProperty(_prop, node) : _prop[0] === '$') {
|
|
continue;
|
|
}
|
|
|
|
var child = node[_prop];
|
|
|
|
// Collection node.
|
|
//
|
|
// NOTE: a node (or several nodes) can be removed or inserted
|
|
// during traversal.
|
|
//
|
|
// Current traversing index is stored on top of the
|
|
// `NodePath.traversingIndexStack`. The stack is used to support
|
|
// recursive nature of the traversal.
|
|
//
|
|
// In this case `NodePath.traversingIndex` (which we use here) is
|
|
// updated in the NodePath remove/insert methods.
|
|
//
|
|
if (Array.isArray(child)) {
|
|
var index = 0;
|
|
NodePath$2.traversingIndexStack.push(index);
|
|
while (index < child.length) {
|
|
visit(child[index], node, _prop, index);
|
|
index = NodePath$2.updateTraversingIndex(+1);
|
|
}
|
|
NodePath$2.traversingIndexStack.pop();
|
|
}
|
|
|
|
// Simple node.
|
|
else {
|
|
visit(child, node, _prop);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (post) {
|
|
post(node, parent, prop, idx);
|
|
}
|
|
}
|
|
|
|
visit(root, null);
|
|
}
|
|
|
|
var traverse$1 = {
|
|
/**
|
|
* Traverses an AST.
|
|
*
|
|
* @param Object ast - an AST node
|
|
*
|
|
* @param Object | Array<Object> handlers:
|
|
*
|
|
* an object (or an array of objects)
|
|
*
|
|
* Each such object contains a handler function per node.
|
|
* In case of an array of handlers, they are applied in order.
|
|
* A handler may return a transformed node (or a different type).
|
|
*
|
|
* The per-node function may instead be an object with functions pre and post.
|
|
* pre is called before visiting the node, post after.
|
|
* If a handler is a function, it is treated as the pre function, with an empty post.
|
|
*
|
|
* @param Object options:
|
|
*
|
|
* a config object, specifying traversal options:
|
|
*
|
|
* `asNodes`: boolean - whether handlers should receives raw AST nodes
|
|
* (false by default), instead of a `NodePath` wrapper. Note, by default
|
|
* `NodePath` wrapper provides a set of convenient method to manipulate
|
|
* a traversing AST, and also has access to all parents list. A raw
|
|
* nodes traversal should be used in rare cases, when no `NodePath`
|
|
* features are needed.
|
|
*
|
|
* Special hooks:
|
|
*
|
|
* - `shouldRun(ast)` - a predicate determining whether the handler
|
|
* should be applied.
|
|
*
|
|
* NOTE: Multiple handlers are used as an optimization of applying all of
|
|
* them in one AST traversal pass.
|
|
*/
|
|
traverse: function traverse(ast, handlers) {
|
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : { asNodes: false };
|
|
|
|
|
|
if (!Array.isArray(handlers)) {
|
|
handlers = [handlers];
|
|
}
|
|
|
|
// Filter out handlers by result of `shouldRun`, if the method is present.
|
|
handlers = handlers.filter(function (handler) {
|
|
if (typeof handler.shouldRun !== 'function') {
|
|
return true;
|
|
}
|
|
return handler.shouldRun(ast);
|
|
});
|
|
|
|
NodePath$2.initRegistry();
|
|
|
|
// Allow handlers to initializer themselves.
|
|
handlers.forEach(function (handler) {
|
|
if (typeof handler.init === 'function') {
|
|
handler.init(ast);
|
|
}
|
|
});
|
|
|
|
function getPathFor(node, parent, prop, index) {
|
|
var parentPath = NodePath$2.getForNode(parent);
|
|
var nodePath = NodePath$2.getForNode(node, parentPath, prop, index);
|
|
|
|
return nodePath;
|
|
}
|
|
|
|
// Handle actual nodes.
|
|
astTraverse(ast, {
|
|
/**
|
|
* Handler on node enter.
|
|
*/
|
|
pre: function pre(node, parent, prop, index) {
|
|
var nodePath = void 0;
|
|
if (!options.asNodes) {
|
|
nodePath = getPathFor(node, parent, prop, index);
|
|
}
|
|
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = handlers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var handler = _step.value;
|
|
|
|
// "Catch-all" `*` handler.
|
|
if (typeof handler['*'] === 'function') {
|
|
if (nodePath) {
|
|
// A path/node can be removed by some previous handler.
|
|
if (!nodePath.isRemoved()) {
|
|
var handlerResult = handler['*'](nodePath);
|
|
// Explicitly stop traversal.
|
|
if (handlerResult === false) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
handler['*'](node, parent, prop, index);
|
|
}
|
|
}
|
|
|
|
// Per-node handler.
|
|
var handlerFuncPre = void 0;
|
|
if (typeof handler[node.type] === 'function') {
|
|
handlerFuncPre = handler[node.type];
|
|
} else if (typeof handler[node.type] === 'object' && typeof handler[node.type].pre === 'function') {
|
|
handlerFuncPre = handler[node.type].pre;
|
|
}
|
|
|
|
if (handlerFuncPre) {
|
|
if (nodePath) {
|
|
// A path/node can be removed by some previous handler.
|
|
if (!nodePath.isRemoved()) {
|
|
var _handlerResult = handlerFuncPre.call(handler, nodePath);
|
|
// Explicitly stop traversal.
|
|
if (_handlerResult === false) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
handlerFuncPre.call(handler, node, parent, prop, index);
|
|
}
|
|
}
|
|
} // Loop over handlers
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// pre func
|
|
|
|
/**
|
|
* Handler on node exit.
|
|
*/
|
|
post: function post(node, parent, prop, index) {
|
|
if (!node) {
|
|
return;
|
|
}
|
|
|
|
var nodePath = void 0;
|
|
if (!options.asNodes) {
|
|
nodePath = getPathFor(node, parent, prop, index);
|
|
}
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = handlers[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var handler = _step2.value;
|
|
|
|
// Per-node handler.
|
|
var handlerFuncPost = void 0;
|
|
if (typeof handler[node.type] === 'object' && typeof handler[node.type].post === 'function') {
|
|
handlerFuncPost = handler[node.type].post;
|
|
}
|
|
|
|
if (handlerFuncPost) {
|
|
if (nodePath) {
|
|
// A path/node can be removed by some previous handler.
|
|
if (!nodePath.isRemoved()) {
|
|
var handlerResult = handlerFuncPost.call(handler, nodePath);
|
|
// Explicitly stop traversal.
|
|
if (handlerResult === false) {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
handlerFuncPost.call(handler, node, parent, prop, index);
|
|
}
|
|
}
|
|
} // Loop over handlers
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
// post func
|
|
|
|
/**
|
|
* Skip locations by default.
|
|
*/
|
|
skipProperty: function skipProperty(prop) {
|
|
return prop === 'loc';
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _createClass$5 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var generator$2 = generator_1;
|
|
var parser$3 = parser$4;
|
|
var traverse = traverse$1;
|
|
|
|
/**
|
|
* Transform result.
|
|
*/
|
|
|
|
var TransformResult = function () {
|
|
/**
|
|
* Initializes a transform result for an AST.
|
|
*
|
|
* @param Object ast - an AST node
|
|
* @param mixed extra - any extra data a transform may return
|
|
*/
|
|
function TransformResult(ast) {
|
|
var extra = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
|
|
_classCallCheck$5(this, TransformResult);
|
|
|
|
this._ast = ast;
|
|
this._source = null;
|
|
this._string = null;
|
|
this._regexp = null;
|
|
this._extra = extra;
|
|
}
|
|
|
|
_createClass$5(TransformResult, [{
|
|
key: 'getAST',
|
|
value: function getAST() {
|
|
return this._ast;
|
|
}
|
|
}, {
|
|
key: 'setExtra',
|
|
value: function setExtra(extra) {
|
|
this._extra = extra;
|
|
}
|
|
}, {
|
|
key: 'getExtra',
|
|
value: function getExtra() {
|
|
return this._extra;
|
|
}
|
|
}, {
|
|
key: 'toRegExp',
|
|
value: function toRegExp() {
|
|
if (!this._regexp) {
|
|
this._regexp = new RegExp(this.getSource(), this._ast.flags);
|
|
}
|
|
return this._regexp;
|
|
}
|
|
}, {
|
|
key: 'getSource',
|
|
value: function getSource() {
|
|
if (!this._source) {
|
|
this._source = generator$2.generate(this._ast.body);
|
|
}
|
|
return this._source;
|
|
}
|
|
}, {
|
|
key: 'getFlags',
|
|
value: function getFlags() {
|
|
return this._ast.flags;
|
|
}
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString() {
|
|
if (!this._string) {
|
|
this._string = generator$2.generate(this._ast);
|
|
}
|
|
return this._string;
|
|
}
|
|
}]);
|
|
|
|
return TransformResult;
|
|
}();
|
|
|
|
var transform$1 = {
|
|
/**
|
|
* Expose `TransformResult`.
|
|
*/
|
|
TransformResult: TransformResult,
|
|
|
|
/**
|
|
* Transforms a regular expression applying a set of
|
|
* transformation handlers.
|
|
*
|
|
* @param string | AST | RegExp:
|
|
*
|
|
* a regular expression in different representations: a string,
|
|
* a RegExp object, or an AST.
|
|
*
|
|
* @param Object | Array<Object>:
|
|
*
|
|
* a handler (or a list of handlers) from `traverse` API.
|
|
*
|
|
* @return TransformResult instance.
|
|
*
|
|
* Example:
|
|
*
|
|
* transform(/[a-z]/i, {
|
|
* onChar(path) {
|
|
* const {node} = path;
|
|
*
|
|
* if (...) {
|
|
* path.remove();
|
|
* }
|
|
* }
|
|
* });
|
|
*/
|
|
transform: function transform(regexp, handlers) {
|
|
var ast = regexp;
|
|
|
|
if (regexp instanceof RegExp) {
|
|
regexp = '' + regexp;
|
|
}
|
|
|
|
if (typeof regexp === 'string') {
|
|
ast = parser$3.parse(regexp, {
|
|
captureLocations: true
|
|
});
|
|
}
|
|
|
|
traverse.traverse(ast, handlers);
|
|
|
|
return new TransformResult(ast);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var compatTransforms = transforms$1;
|
|
var _transform$1 = transform$1;
|
|
|
|
var compatTranspiler$1 = {
|
|
/**
|
|
* Translates a regexp in new syntax to equivalent regexp in old syntax.
|
|
*
|
|
* @param string|RegExp|AST - regexp
|
|
* @param Array transformsWhitelist - names of the transforms to apply
|
|
*/
|
|
transform: function transform(regexp) {
|
|
var transformsWhitelist = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
|
|
var transformToApply = transformsWhitelist.length > 0 ? transformsWhitelist : Object.keys(compatTransforms);
|
|
|
|
var result = void 0;
|
|
|
|
// Collect extra data per transform.
|
|
var extra = {};
|
|
|
|
transformToApply.forEach(function (transformName) {
|
|
|
|
if (!compatTransforms.hasOwnProperty(transformName)) {
|
|
throw new Error('Unknown compat-transform: ' + transformName + '. ' + 'Available transforms are: ' + Object.keys(compatTransforms).join(', '));
|
|
}
|
|
|
|
var handler = compatTransforms[transformName];
|
|
|
|
result = _transform$1.transform(regexp, handler);
|
|
regexp = result.getAST();
|
|
|
|
// Collect `extra` transform result.
|
|
if (typeof handler.getExtra === 'function') {
|
|
extra[transformName] = handler.getExtra();
|
|
}
|
|
});
|
|
|
|
// Set the final extras for all transforms.
|
|
result.setExtra(extra);
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* Performs a deep copy of an simple object.
|
|
* Only handles scalar values, arrays and objects.
|
|
*
|
|
* @param obj Object
|
|
*/
|
|
|
|
var clone$1 = function clone(obj) {
|
|
if (obj === null || typeof obj !== 'object') {
|
|
return obj;
|
|
}
|
|
var res = void 0;
|
|
if (Array.isArray(obj)) {
|
|
res = [];
|
|
} else {
|
|
res = {};
|
|
}
|
|
for (var i in obj) {
|
|
res[i] = clone(obj[i]);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to transform surrogate pairs into single unicode code point
|
|
*
|
|
* \ud83d\ude80 -> \u{1f680}
|
|
*/
|
|
|
|
var charSurrogatePairToSingleUnicodeTransform = {
|
|
shouldRun: function shouldRun(ast) {
|
|
return ast.flags.includes('u');
|
|
},
|
|
Char: function Char(path) {
|
|
var node = path.node;
|
|
|
|
if (node.kind !== 'unicode' || !node.isSurrogatePair || isNaN(node.codePoint)) {
|
|
return;
|
|
}
|
|
node.value = '\\u{' + node.codePoint.toString(16) + '}';
|
|
delete node.isSurrogatePair;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var UPPER_A_CP$1 = 'A'.codePointAt(0);
|
|
var UPPER_Z_CP$1 = 'Z'.codePointAt(0);
|
|
var LOWER_A_CP = 'a'.codePointAt(0);
|
|
var LOWER_Z_CP = 'z'.codePointAt(0);
|
|
var DIGIT_0_CP = '0'.codePointAt(0);
|
|
var DIGIT_9_CP = '9'.codePointAt(0);
|
|
|
|
/**
|
|
* A regexp-tree plugin to transform coded chars into simple chars.
|
|
*
|
|
* \u0061 -> a
|
|
*/
|
|
var charCodeToSimpleCharTransform = {
|
|
Char: function Char(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
if (isNaN(node.codePoint) || node.kind === 'simple') {
|
|
return;
|
|
}
|
|
|
|
if (parent.type === 'ClassRange') {
|
|
if (!isSimpleRange(parent)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!isPrintableASCIIChar(node.codePoint)) {
|
|
return;
|
|
}
|
|
|
|
var symbol = String.fromCodePoint(node.codePoint);
|
|
var newChar = {
|
|
type: 'Char',
|
|
kind: 'simple',
|
|
value: symbol,
|
|
symbol: symbol,
|
|
codePoint: node.codePoint
|
|
};
|
|
if (needsEscape(symbol, parent.type)) {
|
|
newChar.escaped = true;
|
|
}
|
|
path.replace(newChar);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Checks if a range is included either in 0-9, a-z or A-Z
|
|
* @param classRange
|
|
* @returns {boolean}
|
|
*/
|
|
function isSimpleRange(classRange) {
|
|
var from = classRange.from,
|
|
to = classRange.to;
|
|
|
|
return from.codePoint >= DIGIT_0_CP && from.codePoint <= DIGIT_9_CP && to.codePoint >= DIGIT_0_CP && to.codePoint <= DIGIT_9_CP || from.codePoint >= UPPER_A_CP$1 && from.codePoint <= UPPER_Z_CP$1 && to.codePoint >= UPPER_A_CP$1 && to.codePoint <= UPPER_Z_CP$1 || from.codePoint >= LOWER_A_CP && from.codePoint <= LOWER_Z_CP && to.codePoint >= LOWER_A_CP && to.codePoint <= LOWER_Z_CP;
|
|
}
|
|
|
|
/**
|
|
* Checks if a code point in the range of printable ASCII chars
|
|
* (DEL char excluded)
|
|
* @param codePoint
|
|
* @returns {boolean}
|
|
*/
|
|
function isPrintableASCIIChar(codePoint) {
|
|
return codePoint >= 0x20 && codePoint <= 0x7e;
|
|
}
|
|
|
|
function needsEscape(symbol, parentType) {
|
|
if (parentType === 'ClassRange' || parentType === 'CharacterClass') {
|
|
return (/[\]\\^-]/.test(symbol)
|
|
);
|
|
}
|
|
|
|
return (/[*[()+?^$./\\|{}]/.test(symbol)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var UPPER_A_CP = 'A'.codePointAt(0);
|
|
var UPPER_Z_CP = 'Z'.codePointAt(0);
|
|
/**
|
|
* Transforms case-insensitive regexp to lowercase
|
|
*
|
|
* /AaBbÏ/i -> /aabbï/i
|
|
*/
|
|
var charCaseInsensitiveLowercaseTransform = {
|
|
_AZClassRanges: null,
|
|
_hasUFlag: false,
|
|
init: function init(ast) {
|
|
this._AZClassRanges = new Set();
|
|
this._hasUFlag = ast.flags.includes('u');
|
|
},
|
|
shouldRun: function shouldRun(ast) {
|
|
return ast.flags.includes('i');
|
|
},
|
|
Char: function Char(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
if (isNaN(node.codePoint)) {
|
|
return;
|
|
}
|
|
|
|
// Engine support for case-insensitive matching without the u flag
|
|
// for characters above \u1000 does not seem reliable.
|
|
if (!this._hasUFlag && node.codePoint >= 0x1000) {
|
|
return;
|
|
}
|
|
|
|
if (parent.type === 'ClassRange') {
|
|
// The only class ranges we handle must be inside A-Z.
|
|
// After the `from` char is processed, the isAZClassRange test
|
|
// will be false, so we use a Set to keep track of parents and
|
|
// process the `to` char.
|
|
if (!this._AZClassRanges.has(parent) && !isAZClassRange(parent)) {
|
|
return;
|
|
}
|
|
this._AZClassRanges.add(parent);
|
|
}
|
|
|
|
var lower = node.symbol.toLowerCase();
|
|
if (lower !== node.symbol) {
|
|
node.value = displaySymbolAsValue(lower, node);
|
|
node.symbol = lower;
|
|
node.codePoint = lower.codePointAt(0);
|
|
}
|
|
}
|
|
};
|
|
|
|
function isAZClassRange(classRange) {
|
|
var from = classRange.from,
|
|
to = classRange.to;
|
|
// A-Z
|
|
|
|
return from.codePoint >= UPPER_A_CP && from.codePoint <= UPPER_Z_CP && to.codePoint >= UPPER_A_CP && to.codePoint <= UPPER_Z_CP;
|
|
}
|
|
|
|
function displaySymbolAsValue(symbol, node) {
|
|
var codePoint = symbol.codePointAt(0);
|
|
if (node.kind === 'decimal') {
|
|
return '\\' + codePoint;
|
|
}
|
|
if (node.kind === 'oct') {
|
|
return '\\0' + codePoint.toString(8);
|
|
}
|
|
if (node.kind === 'hex') {
|
|
return '\\x' + codePoint.toString(16);
|
|
}
|
|
if (node.kind === 'unicode') {
|
|
if (node.isSurrogatePair) {
|
|
var _getSurrogatePairFrom = getSurrogatePairFromCodePoint(codePoint),
|
|
lead = _getSurrogatePairFrom.lead,
|
|
trail = _getSurrogatePairFrom.trail;
|
|
|
|
return '\\u' + '0'.repeat(4 - lead.length) + lead + '\\u' + '0'.repeat(4 - trail.length) + trail;
|
|
} else if (node.value.includes('{')) {
|
|
return '\\u{' + codePoint.toString(16) + '}';
|
|
} else {
|
|
var code = codePoint.toString(16);
|
|
return '\\u' + '0'.repeat(4 - code.length) + code;
|
|
}
|
|
}
|
|
// simple
|
|
return symbol;
|
|
}
|
|
|
|
/**
|
|
* Converts a code point to a surrogate pair.
|
|
* Conversion algorithm is taken from The Unicode Standard 3.0 Section 3.7
|
|
* (https://www.unicode.org/versions/Unicode3.0.0/ch03.pdf)
|
|
* @param {number} codePoint - Between 0x10000 and 0x10ffff
|
|
* @returns {{lead: string, trail: string}}
|
|
*/
|
|
function getSurrogatePairFromCodePoint(codePoint) {
|
|
var lead = Math.floor((codePoint - 0x10000) / 0x400) + 0xd800;
|
|
var trail = (codePoint - 0x10000) % 0x400 + 0xdc00;
|
|
return {
|
|
lead: lead.toString(16),
|
|
trail: trail.toString(16)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to remove duplicates from character classes.
|
|
*/
|
|
|
|
var charClassRemoveDuplicatesTransform = {
|
|
CharacterClass: function CharacterClass(path) {
|
|
var node = path.node;
|
|
|
|
var sources = {};
|
|
|
|
for (var i = 0; i < node.expressions.length; i++) {
|
|
var childPath = path.getChild(i);
|
|
var source = childPath.jsonEncode();
|
|
|
|
if (sources.hasOwnProperty(source)) {
|
|
childPath.remove();
|
|
|
|
// Since we remove the current node.
|
|
// TODO: make it simpler for users with a method.
|
|
i--;
|
|
}
|
|
|
|
sources[source] = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* Flattens a nested disjunction node to a list.
|
|
*
|
|
* /a|b|c|d/
|
|
*
|
|
* {{{a, b}, c}, d} -> [a, b, c, d]
|
|
*/
|
|
|
|
function _toConsumableArray$7(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
function disjunctionToList$1(node) {
|
|
if (node.type !== 'Disjunction') {
|
|
throw new TypeError('Expected "Disjunction" node, got "' + node.type + '"');
|
|
}
|
|
|
|
var list = [];
|
|
|
|
if (node.left && node.left.type === 'Disjunction') {
|
|
list.push.apply(list, _toConsumableArray$7(disjunctionToList$1(node.left)).concat([node.right]));
|
|
} else {
|
|
list.push(node.left, node.right);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Builds a nested disjunction node from a list.
|
|
*
|
|
* /a|b|c|d/
|
|
*
|
|
* [a, b, c, d] -> {{{a, b}, c}, d}
|
|
*/
|
|
function listToDisjunction$1(list) {
|
|
return list.reduce(function (left, right) {
|
|
return {
|
|
type: 'Disjunction',
|
|
left: left,
|
|
right: right
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Increases a quantifier by one.
|
|
* Does not change greediness.
|
|
* * -> +
|
|
* + -> {2,}
|
|
* ? -> {1,2}
|
|
* {2} -> {3}
|
|
* {2,} -> {3,}
|
|
* {2,3} -> {3,4}
|
|
*/
|
|
function increaseQuantifierByOne$2(quantifier) {
|
|
if (quantifier.kind === '*') {
|
|
|
|
quantifier.kind = '+';
|
|
} else if (quantifier.kind === '+') {
|
|
|
|
quantifier.kind = 'Range';
|
|
quantifier.from = 2;
|
|
delete quantifier.to;
|
|
} else if (quantifier.kind === '?') {
|
|
|
|
quantifier.kind = 'Range';
|
|
quantifier.from = 1;
|
|
quantifier.to = 2;
|
|
} else if (quantifier.kind === 'Range') {
|
|
|
|
quantifier.from += 1;
|
|
if (quantifier.to) {
|
|
quantifier.to += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
var utils = {
|
|
disjunctionToList: disjunctionToList$1,
|
|
listToDisjunction: listToDisjunction$1,
|
|
increaseQuantifierByOne: increaseQuantifierByOne$2
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _require$8 = utils,
|
|
increaseQuantifierByOne$1 = _require$8.increaseQuantifierByOne;
|
|
|
|
/**
|
|
* A regexp-tree plugin to merge quantifiers
|
|
*
|
|
* a+a+ -> a{2,}
|
|
* a{2}a{3} -> a{5}
|
|
* a{1,2}a{2,3} -> a{3,5}
|
|
*/
|
|
|
|
|
|
var quantifiersMergeTransform = {
|
|
Repetition: function Repetition(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
|
|
if (parent.type !== 'Alternative' || !path.index) {
|
|
return;
|
|
}
|
|
|
|
var previousSibling = path.getPreviousSibling();
|
|
|
|
if (!previousSibling) {
|
|
return;
|
|
}
|
|
|
|
if (previousSibling.node.type === 'Repetition') {
|
|
if (!previousSibling.getChild().hasEqualSource(path.getChild())) {
|
|
return;
|
|
}
|
|
|
|
var _extractFromTo = extractFromTo(previousSibling.node.quantifier),
|
|
previousSiblingFrom = _extractFromTo.from,
|
|
previousSiblingTo = _extractFromTo.to;
|
|
|
|
var _extractFromTo2 = extractFromTo(node.quantifier),
|
|
nodeFrom = _extractFromTo2.from,
|
|
nodeTo = _extractFromTo2.to;
|
|
|
|
// It's does not seem reliable to merge quantifiers with different greediness
|
|
// when none of both is a greedy open range
|
|
|
|
|
|
if (previousSibling.node.quantifier.greedy !== node.quantifier.greedy && !isGreedyOpenRange(previousSibling.node.quantifier) && !isGreedyOpenRange(node.quantifier)) {
|
|
return;
|
|
}
|
|
|
|
// a*a* -> a*
|
|
// a*a+ -> a+
|
|
// a+a+ -> a{2,}
|
|
// a{2}a{4} -> a{6}
|
|
// a{1,2}a{2,3} -> a{3,5}
|
|
// a{1,}a{2,} -> a{3,}
|
|
// a+a{2,} -> a{3,}
|
|
|
|
// a??a{2,} -> a{2,}
|
|
// a*?a{2,} -> a{2,}
|
|
// a+?a{2,} -> a{3,}
|
|
|
|
node.quantifier.kind = 'Range';
|
|
node.quantifier.from = previousSiblingFrom + nodeFrom;
|
|
if (previousSiblingTo && nodeTo) {
|
|
node.quantifier.to = previousSiblingTo + nodeTo;
|
|
} else {
|
|
delete node.quantifier.to;
|
|
}
|
|
if (isGreedyOpenRange(previousSibling.node.quantifier) || isGreedyOpenRange(node.quantifier)) {
|
|
node.quantifier.greedy = true;
|
|
}
|
|
|
|
previousSibling.remove();
|
|
} else {
|
|
if (!previousSibling.hasEqualSource(path.getChild())) {
|
|
return;
|
|
}
|
|
|
|
increaseQuantifierByOne$1(node.quantifier);
|
|
previousSibling.remove();
|
|
}
|
|
}
|
|
};
|
|
|
|
function isGreedyOpenRange(quantifier) {
|
|
return quantifier.greedy && (quantifier.kind === '+' || quantifier.kind === '*' || quantifier.kind === 'Range' && !quantifier.to);
|
|
}
|
|
|
|
function extractFromTo(quantifier) {
|
|
var from = void 0,
|
|
to = void 0;
|
|
if (quantifier.kind === '*') {
|
|
from = 0;
|
|
} else if (quantifier.kind === '+') {
|
|
from = 1;
|
|
} else if (quantifier.kind === '?') {
|
|
from = 0;
|
|
to = 1;
|
|
} else {
|
|
from = quantifier.from;
|
|
if (quantifier.to) {
|
|
to = quantifier.to;
|
|
}
|
|
}
|
|
return { from: from, to: to };
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to replace different range-based quantifiers
|
|
* with their symbol equivalents.
|
|
*
|
|
* a{0,} -> a*
|
|
* a{1,} -> a+
|
|
* a{1} -> a
|
|
*
|
|
* NOTE: the following is automatically handled in the generator:
|
|
*
|
|
* a{3,3} -> a{3}
|
|
*/
|
|
|
|
var quantifierRangeToSymbolTransform = {
|
|
Quantifier: function Quantifier(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.kind !== 'Range') {
|
|
return;
|
|
}
|
|
|
|
// a{0,} -> a*
|
|
rewriteOpenZero(path);
|
|
|
|
// a{1,} -> a+
|
|
rewriteOpenOne(path);
|
|
|
|
// a{1} -> a
|
|
rewriteExactOne(path);
|
|
}
|
|
};
|
|
|
|
function rewriteOpenZero(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.from !== 0 || node.to) {
|
|
return;
|
|
}
|
|
|
|
node.kind = '*';
|
|
delete node.from;
|
|
}
|
|
|
|
function rewriteOpenOne(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.from !== 1 || node.to) {
|
|
return;
|
|
}
|
|
|
|
node.kind = '+';
|
|
delete node.from;
|
|
}
|
|
|
|
function rewriteExactOne(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.from !== 1 || node.to !== 1) {
|
|
return;
|
|
}
|
|
|
|
path.parentPath.replace(path.parentPath.node.expression);
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to simplify character classes
|
|
* spanning only one or two chars.
|
|
*
|
|
* [a-a] -> [a]
|
|
* [a-b] -> [ab]
|
|
*/
|
|
|
|
var charClassClassrangesToCharsTransform = {
|
|
ClassRange: function ClassRange(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.from.codePoint === node.to.codePoint) {
|
|
|
|
path.replace(node.from);
|
|
} else if (node.from.codePoint === node.to.codePoint - 1) {
|
|
|
|
path.getParent().insertChildAt(node.to, path.index + 1);
|
|
path.replace(node.from);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to replace standard character classes with
|
|
* their meta symbols equivalents.
|
|
*/
|
|
|
|
function _toConsumableArray$6(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var charClassToMetaTransform = {
|
|
_hasIFlag: false,
|
|
_hasUFlag: false,
|
|
init: function init(ast) {
|
|
this._hasIFlag = ast.flags.includes('i');
|
|
this._hasUFlag = ast.flags.includes('u');
|
|
},
|
|
CharacterClass: function CharacterClass(path) {
|
|
// [0-9] -> \d
|
|
rewriteNumberRanges(path);
|
|
|
|
// [a-zA-Z_0-9] -> \w
|
|
rewriteWordRanges(path, this._hasIFlag, this._hasUFlag);
|
|
|
|
// [ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff] -> \s
|
|
rewriteWhitespaceRanges(path);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Rewrites number ranges: [0-9] -> \d
|
|
*/
|
|
function rewriteNumberRanges(path) {
|
|
var node = path.node;
|
|
|
|
|
|
node.expressions.forEach(function (expression, i) {
|
|
if (isFullNumberRange(expression)) {
|
|
path.getChild(i).replace({
|
|
type: 'Char',
|
|
value: '\\d',
|
|
kind: 'meta'
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Rewrites word ranges: [a-zA-Z_0-9] -> \w
|
|
* Thus, the ranges may go in any order, and other symbols/ranges
|
|
* are kept untouched, e.g. [a-z_\dA-Z$] -> [\w$]
|
|
*/
|
|
function rewriteWordRanges(path, hasIFlag, hasUFlag) {
|
|
var node = path.node;
|
|
|
|
|
|
var numberPath = null;
|
|
var lowerCasePath = null;
|
|
var upperCasePath = null;
|
|
var underscorePath = null;
|
|
var u017fPath = null;
|
|
var u212aPath = null;
|
|
|
|
node.expressions.forEach(function (expression, i) {
|
|
// \d
|
|
if (isMetaChar(expression, '\\d')) {
|
|
numberPath = path.getChild(i);
|
|
}
|
|
|
|
// a-z
|
|
else if (isLowerCaseRange(expression)) {
|
|
lowerCasePath = path.getChild(i);
|
|
}
|
|
|
|
// A-Z
|
|
else if (isUpperCaseRange(expression)) {
|
|
upperCasePath = path.getChild(i);
|
|
}
|
|
|
|
// _
|
|
else if (isUnderscore(expression)) {
|
|
underscorePath = path.getChild(i);
|
|
} else if (hasIFlag && hasUFlag && isCodePoint(expression, 0x017f)) {
|
|
u017fPath = path.getChild(i);
|
|
} else if (hasIFlag && hasUFlag && isCodePoint(expression, 0x212a)) {
|
|
u212aPath = path.getChild(i);
|
|
}
|
|
});
|
|
|
|
// If we found the whole pattern, replace it.
|
|
if (numberPath && (lowerCasePath && upperCasePath || hasIFlag && (lowerCasePath || upperCasePath)) && underscorePath && (!hasUFlag || !hasIFlag || u017fPath && u212aPath)) {
|
|
// Put \w in place of \d.
|
|
numberPath.replace({
|
|
type: 'Char',
|
|
value: '\\w',
|
|
kind: 'meta'
|
|
});
|
|
|
|
// Other paths are removed.
|
|
if (lowerCasePath) {
|
|
lowerCasePath.remove();
|
|
}
|
|
if (upperCasePath) {
|
|
upperCasePath.remove();
|
|
}
|
|
underscorePath.remove();
|
|
if (u017fPath) {
|
|
u017fPath.remove();
|
|
}
|
|
if (u212aPath) {
|
|
u212aPath.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rewrites whitespace ranges: [ \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff] -> \s.
|
|
*/
|
|
var whitespaceRangeTests = [function (node) {
|
|
return isChar(node, ' ');
|
|
}].concat(_toConsumableArray$6(['\\f', '\\n', '\\r', '\\t', '\\v'].map(function (char) {
|
|
return function (node) {
|
|
return isMetaChar(node, char);
|
|
};
|
|
})), _toConsumableArray$6([0x00a0, 0x1680, 0x2028, 0x2029, 0x202f, 0x205f, 0x3000, 0xfeff].map(function (codePoint) {
|
|
return function (node) {
|
|
return isCodePoint(node, codePoint);
|
|
};
|
|
})), [function (node) {
|
|
return node.type === 'ClassRange' && isCodePoint(node.from, 0x2000) && isCodePoint(node.to, 0x200a);
|
|
}]);
|
|
|
|
function rewriteWhitespaceRanges(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.expressions.length < whitespaceRangeTests.length || !whitespaceRangeTests.every(function (test) {
|
|
return node.expressions.some(function (expression) {
|
|
return test(expression);
|
|
});
|
|
})) {
|
|
return;
|
|
}
|
|
|
|
// If we found the whole pattern, replace it.
|
|
|
|
// Put \s in place of \n.
|
|
var nNode = node.expressions.find(function (expression) {
|
|
return isMetaChar(expression, '\\n');
|
|
});
|
|
nNode.value = '\\s';
|
|
nNode.symbol = undefined;
|
|
nNode.codePoint = NaN;
|
|
|
|
// Other paths are removed.
|
|
node.expressions.map(function (expression, i) {
|
|
return whitespaceRangeTests.some(function (test) {
|
|
return test(expression);
|
|
}) ? path.getChild(i) : undefined;
|
|
}).filter(Boolean).forEach(function (path) {
|
|
return path.remove();
|
|
});
|
|
}
|
|
|
|
function isFullNumberRange(node) {
|
|
return node.type === 'ClassRange' && node.from.value === '0' && node.to.value === '9';
|
|
}
|
|
|
|
function isChar(node, value) {
|
|
var kind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'simple';
|
|
|
|
return node.type === 'Char' && node.value === value && node.kind === kind;
|
|
}
|
|
|
|
function isMetaChar(node, value) {
|
|
return isChar(node, value, 'meta');
|
|
}
|
|
|
|
function isLowerCaseRange(node) {
|
|
return node.type === 'ClassRange' && node.from.value === 'a' && node.to.value === 'z';
|
|
}
|
|
|
|
function isUpperCaseRange(node) {
|
|
return node.type === 'ClassRange' && node.from.value === 'A' && node.to.value === 'Z';
|
|
}
|
|
|
|
function isUnderscore(node) {
|
|
return node.type === 'Char' && node.value === '_' && node.kind === 'simple';
|
|
}
|
|
|
|
function isCodePoint(node, codePoint) {
|
|
return node.type === 'Char' && node.kind === 'unicode' && node.codePoint === codePoint;
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to replace single char character classes with
|
|
* just that character.
|
|
*
|
|
* [\d] -> \d, [^\w] -> \W
|
|
*/
|
|
|
|
var charClassToSingleCharTransform = {
|
|
CharacterClass: function CharacterClass(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.expressions.length !== 1 || !hasAppropriateSiblings$1(path) || !isAppropriateChar(node.expressions[0])) {
|
|
return;
|
|
}
|
|
|
|
var _node$expressions$ = node.expressions[0],
|
|
value = _node$expressions$.value,
|
|
kind = _node$expressions$.kind,
|
|
escaped = _node$expressions$.escaped;
|
|
|
|
|
|
if (node.negative) {
|
|
// For negative can extract only meta chars like [^\w] -> \W
|
|
// cannot do for [^a] -> a (wrong).
|
|
if (!isMeta$1(value)) {
|
|
return;
|
|
}
|
|
|
|
value = getInverseMeta(value);
|
|
}
|
|
|
|
path.replace({
|
|
type: 'Char',
|
|
value: value,
|
|
kind: kind,
|
|
escaped: escaped || shouldEscape(value)
|
|
});
|
|
}
|
|
};
|
|
|
|
function isAppropriateChar(node) {
|
|
return node.type === 'Char' &&
|
|
// We don't extract [\b] (backspace) since \b has different
|
|
// semantics (word boundary).
|
|
node.value !== '\\b';
|
|
}
|
|
|
|
function isMeta$1(value) {
|
|
return (/^\\[dwsDWS]$/.test(value)
|
|
);
|
|
}
|
|
|
|
function getInverseMeta(value) {
|
|
return (/[dws]/.test(value) ? value.toUpperCase() : value.toLowerCase()
|
|
);
|
|
}
|
|
|
|
function hasAppropriateSiblings$1(path) {
|
|
var parent = path.parent,
|
|
index = path.index;
|
|
|
|
|
|
if (parent.type !== 'Alternative') {
|
|
return true;
|
|
}
|
|
|
|
var previousNode = parent.expressions[index - 1];
|
|
if (previousNode == null) {
|
|
return true;
|
|
}
|
|
|
|
// Don't optimized \1[0] to \10
|
|
if (previousNode.type === 'Backreference' && previousNode.kind === 'number') {
|
|
return false;
|
|
}
|
|
|
|
// Don't optimized \2[0] to \20
|
|
if (previousNode.type === 'Char' && previousNode.kind === 'decimal') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Note: \{ and \} are always preserved to avoid `a[{]2[}]` turning
|
|
// into `a{2}`.
|
|
function shouldEscape(value) {
|
|
return (/[*[()+?$./{}|]/.test(value)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to remove unnecessary escape.
|
|
*
|
|
* \e -> e
|
|
*
|
|
* [\(] -> [(]
|
|
*/
|
|
|
|
var charEscapeUnescapeTransform = {
|
|
_hasXFlag: false,
|
|
init: function init(ast) {
|
|
this._hasXFlag = ast.flags.includes('x');
|
|
},
|
|
Char: function Char(path) {
|
|
var node = path.node;
|
|
|
|
|
|
if (!node.escaped) {
|
|
return;
|
|
}
|
|
|
|
if (shouldUnescape(path, this._hasXFlag)) {
|
|
delete node.escaped;
|
|
}
|
|
}
|
|
};
|
|
|
|
function shouldUnescape(path, hasXFlag) {
|
|
var value = path.node.value,
|
|
index = path.index,
|
|
parent = path.parent;
|
|
|
|
// In char class (, etc are allowed.
|
|
|
|
if (parent.type !== 'CharacterClass' && parent.type !== 'ClassRange') {
|
|
return !preservesEscape(value, index, parent, hasXFlag);
|
|
}
|
|
|
|
return !preservesInCharClass(value, index, parent);
|
|
}
|
|
|
|
/**
|
|
* \], \\, \^, \-
|
|
*/
|
|
function preservesInCharClass(value, index, parent) {
|
|
if (value === '^') {
|
|
// Avoid [\^a] turning into [^a]
|
|
return index === 0 && !parent.negative;
|
|
}
|
|
if (value === '-') {
|
|
// Avoid [a\-z] turning into [a-z]
|
|
return true;
|
|
}
|
|
return (/[\]\\]/.test(value)
|
|
);
|
|
}
|
|
|
|
function preservesEscape(value, index, parent, hasXFlag) {
|
|
if (value === '{') {
|
|
return preservesOpeningCurlyBraceEscape(index, parent);
|
|
}
|
|
|
|
if (value === '}') {
|
|
return preservesClosingCurlyBraceEscape(index, parent);
|
|
}
|
|
|
|
if (hasXFlag && /[ #]/.test(value)) {
|
|
return true;
|
|
}
|
|
|
|
return (/[*[()+?^$./\\|]/.test(value)
|
|
);
|
|
}
|
|
|
|
function consumeNumbers(startIndex, parent, rtl) {
|
|
var i = startIndex;
|
|
var siblingNode = (rtl ? i >= 0 : i < parent.expressions.length) && parent.expressions[i];
|
|
|
|
while (siblingNode && siblingNode.type === 'Char' && siblingNode.kind === 'simple' && !siblingNode.escaped && /\d/.test(siblingNode.value)) {
|
|
rtl ? i-- : i++;
|
|
siblingNode = (rtl ? i >= 0 : i < parent.expressions.length) && parent.expressions[i];
|
|
}
|
|
|
|
return Math.abs(startIndex - i);
|
|
}
|
|
|
|
function isSimpleChar(node, value) {
|
|
return node && node.type === 'Char' && node.kind === 'simple' && !node.escaped && node.value === value;
|
|
}
|
|
|
|
function preservesOpeningCurlyBraceEscape(index, parent) {
|
|
// (?:\{) -> (?:{)
|
|
if (index == null) {
|
|
return false;
|
|
}
|
|
|
|
var nbFollowingNumbers = consumeNumbers(index + 1, parent);
|
|
var i = index + nbFollowingNumbers + 1;
|
|
var nextSiblingNode = i < parent.expressions.length && parent.expressions[i];
|
|
|
|
if (nbFollowingNumbers) {
|
|
// Avoid \{3} turning into {3}
|
|
if (isSimpleChar(nextSiblingNode, '}')) {
|
|
return true;
|
|
}
|
|
|
|
if (isSimpleChar(nextSiblingNode, ',')) {
|
|
nbFollowingNumbers = consumeNumbers(i + 1, parent);
|
|
i = i + nbFollowingNumbers + 1;
|
|
nextSiblingNode = i < parent.expressions.length && parent.expressions[i];
|
|
|
|
// Avoid \{3,} turning into {3,}
|
|
return isSimpleChar(nextSiblingNode, '}');
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function preservesClosingCurlyBraceEscape(index, parent) {
|
|
// (?:\{) -> (?:{)
|
|
if (index == null) {
|
|
return false;
|
|
}
|
|
|
|
var nbPrecedingNumbers = consumeNumbers(index - 1, parent, true);
|
|
var i = index - nbPrecedingNumbers - 1;
|
|
var previousSiblingNode = i >= 0 && parent.expressions[i];
|
|
|
|
// Avoid {3\} turning into {3}
|
|
if (nbPrecedingNumbers && isSimpleChar(previousSiblingNode, '{')) {
|
|
return true;
|
|
}
|
|
|
|
if (isSimpleChar(previousSiblingNode, ',')) {
|
|
nbPrecedingNumbers = consumeNumbers(i - 1, parent, true);
|
|
i = i - nbPrecedingNumbers - 1;
|
|
previousSiblingNode = i < parent.expressions.length && parent.expressions[i];
|
|
|
|
// Avoid {3,\} turning into {3,}
|
|
return nbPrecedingNumbers && isSimpleChar(previousSiblingNode, '{');
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to merge class ranges.
|
|
*
|
|
* [a-ec] -> [a-e]
|
|
* [a-ec-e] -> [a-e]
|
|
* [\w\da-f] -> [\w]
|
|
* [abcdef] -> [a-f]
|
|
*/
|
|
|
|
var charClassClassrangesMergeTransform = {
|
|
_hasIUFlags: false,
|
|
init: function init(ast) {
|
|
this._hasIUFlags = ast.flags.includes('i') && ast.flags.includes('u');
|
|
},
|
|
CharacterClass: function CharacterClass(path) {
|
|
var node = path.node;
|
|
|
|
var expressions = node.expressions;
|
|
|
|
var metas = [];
|
|
// Extract metas
|
|
expressions.forEach(function (expression) {
|
|
if (isMeta(expression)) {
|
|
metas.push(expression.value);
|
|
}
|
|
});
|
|
|
|
expressions.sort(sortCharClass);
|
|
|
|
for (var i = 0; i < expressions.length; i++) {
|
|
var expression = expressions[i];
|
|
if (fitsInMetas(expression, metas, this._hasIUFlags) || combinesWithPrecedingClassRange(expression, expressions[i - 1]) || combinesWithFollowingClassRange(expression, expressions[i + 1])) {
|
|
expressions.splice(i, 1);
|
|
i--;
|
|
} else {
|
|
var nbMergedChars = charCombinesWithPrecedingChars(expression, i, expressions);
|
|
expressions.splice(i - nbMergedChars + 1, nbMergedChars);
|
|
i -= nbMergedChars;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Sorts expressions in char class in the following order:
|
|
* - meta chars, ordered alphabetically by value
|
|
* - chars (except `control` kind) and class ranges, ordered alphabetically (`from` char is used for class ranges)
|
|
* - if ambiguous, class range comes before char
|
|
* - if ambiguous between two class ranges, orders alphabetically by `to` char
|
|
* - control chars, ordered alphabetically by value
|
|
* @param {Object} a - Left Char or ClassRange node
|
|
* @param {Object} b - Right Char or ClassRange node
|
|
* @returns {number}
|
|
*/
|
|
function sortCharClass(a, b) {
|
|
var aValue = getSortValue(a);
|
|
var bValue = getSortValue(b);
|
|
|
|
if (aValue === bValue) {
|
|
// We want ClassRange before Char
|
|
// [bb-d] -> [b-db]
|
|
if (a.type === 'ClassRange' && b.type !== 'ClassRange') {
|
|
return -1;
|
|
}
|
|
if (b.type === 'ClassRange' && a.type !== 'ClassRange') {
|
|
return 1;
|
|
}
|
|
if (a.type === 'ClassRange' && b.type === 'ClassRange') {
|
|
return getSortValue(a.to) - getSortValue(b.to);
|
|
}
|
|
if (isMeta(a) && isMeta(b) || isControl(a) && isControl(b)) {
|
|
return a.value < b.value ? -1 : 1;
|
|
}
|
|
}
|
|
return aValue - bValue;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @returns {number}
|
|
*/
|
|
function getSortValue(expression) {
|
|
if (expression.type === 'Char') {
|
|
if (expression.value === '-') {
|
|
return Infinity;
|
|
}
|
|
if (expression.kind === 'control') {
|
|
return Infinity;
|
|
}
|
|
if (expression.kind === 'meta' && isNaN(expression.codePoint)) {
|
|
return -1;
|
|
}
|
|
return expression.codePoint;
|
|
}
|
|
// ClassRange
|
|
return expression.from.codePoint;
|
|
}
|
|
|
|
/**
|
|
* Checks if a node is a meta char from the set \d\w\s\D\W\S
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {?string} value
|
|
* @returns {boolean}
|
|
*/
|
|
function isMeta(expression) {
|
|
var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
|
|
return expression.type === 'Char' && expression.kind === 'meta' && (value ? expression.value === value : /^\\[dws]$/i.test(expression.value));
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @returns {boolean}
|
|
*/
|
|
function isControl(expression) {
|
|
return expression.type === 'Char' && expression.kind === 'control';
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {string[]} metas - Array of meta chars, e.g. ["\\w", "\\s"]
|
|
* @param {boolean} hasIUFlags
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInMetas(expression, metas, hasIUFlags) {
|
|
for (var i = 0; i < metas.length; i++) {
|
|
if (fitsInMeta(expression, metas[i], hasIUFlags)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {string} meta - e.g. "\\w"
|
|
* @param {boolean} hasIUFlags
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInMeta(expression, meta, hasIUFlags) {
|
|
if (expression.type === 'ClassRange') {
|
|
return fitsInMeta(expression.from, meta, hasIUFlags) && fitsInMeta(expression.to, meta, hasIUFlags);
|
|
}
|
|
|
|
// Special cases:
|
|
// \S contains \w and \d
|
|
if (meta === '\\S' && (isMeta(expression, '\\w') || isMeta(expression, '\\d'))) {
|
|
return true;
|
|
}
|
|
// \D contains \W and \s
|
|
if (meta === '\\D' && (isMeta(expression, '\\W') || isMeta(expression, '\\s'))) {
|
|
return true;
|
|
}
|
|
// \w contains \d
|
|
if (meta === '\\w' && isMeta(expression, '\\d')) {
|
|
return true;
|
|
}
|
|
// \W contains \s
|
|
if (meta === '\\W' && isMeta(expression, '\\s')) {
|
|
return true;
|
|
}
|
|
|
|
if (expression.type !== 'Char' || isNaN(expression.codePoint)) {
|
|
return false;
|
|
}
|
|
|
|
if (meta === '\\s') {
|
|
return fitsInMetaS(expression);
|
|
}
|
|
if (meta === '\\S') {
|
|
return !fitsInMetaS(expression);
|
|
}
|
|
if (meta === '\\d') {
|
|
return fitsInMetaD(expression);
|
|
}
|
|
if (meta === '\\D') {
|
|
return !fitsInMetaD(expression);
|
|
}
|
|
if (meta === '\\w') {
|
|
return fitsInMetaW(expression, hasIUFlags);
|
|
}
|
|
if (meta === '\\W') {
|
|
return !fitsInMetaW(expression, hasIUFlags);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char node with codePoint
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInMetaS(expression) {
|
|
return expression.codePoint === 0x0009 || // \t
|
|
expression.codePoint === 0x000a || // \n
|
|
expression.codePoint === 0x000b || // \v
|
|
expression.codePoint === 0x000c || // \f
|
|
expression.codePoint === 0x000d || // \r
|
|
expression.codePoint === 0x0020 || // space
|
|
expression.codePoint === 0x00a0 || // nbsp
|
|
expression.codePoint === 0x1680 || // part of Zs
|
|
expression.codePoint >= 0x2000 && expression.codePoint <= 0x200a || // part of Zs
|
|
expression.codePoint === 0x2028 || // line separator
|
|
expression.codePoint === 0x2029 || // paragraph separator
|
|
expression.codePoint === 0x202f || // part of Zs
|
|
expression.codePoint === 0x205f || // part of Zs
|
|
expression.codePoint === 0x3000 || // part of Zs
|
|
expression.codePoint === 0xfeff; // zwnbsp
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char node with codePoint
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInMetaD(expression) {
|
|
return expression.codePoint >= 0x30 && expression.codePoint <= 0x39; // 0-9
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char node with codePoint
|
|
* @param {boolean} hasIUFlags
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInMetaW(expression, hasIUFlags) {
|
|
return fitsInMetaD(expression) || expression.codePoint >= 0x41 && expression.codePoint <= 0x5a || // A-Z
|
|
expression.codePoint >= 0x61 && expression.codePoint <= 0x7a || // a-z
|
|
expression.value === '_' || hasIUFlags && (expression.codePoint === 0x017f || expression.codePoint === 0x212a);
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {Object} classRange - Char or ClassRange node
|
|
* @returns {boolean}
|
|
*/
|
|
function combinesWithPrecedingClassRange(expression, classRange) {
|
|
if (classRange && classRange.type === 'ClassRange') {
|
|
if (fitsInClassRange(expression, classRange)) {
|
|
// [a-gc] -> [a-g]
|
|
// [a-gc-e] -> [a-g]
|
|
return true;
|
|
} else if (
|
|
// We only want \w chars or char codes to keep readability
|
|
isMetaWCharOrCode(expression) && classRange.to.codePoint === expression.codePoint - 1) {
|
|
// [a-de] -> [a-e]
|
|
classRange.to = expression;
|
|
return true;
|
|
} else if (expression.type === 'ClassRange' && expression.from.codePoint <= classRange.to.codePoint + 1 && expression.to.codePoint >= classRange.from.codePoint - 1) {
|
|
// [a-db-f] -> [a-f]
|
|
// [b-fa-d] -> [a-f]
|
|
// [a-cd-f] -> [a-f]
|
|
if (expression.from.codePoint < classRange.from.codePoint) {
|
|
classRange.from = expression.from;
|
|
}
|
|
if (expression.to.codePoint > classRange.to.codePoint) {
|
|
classRange.to = expression.to;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {Object} classRange - Char or ClassRange node
|
|
* @returns {boolean}
|
|
*/
|
|
function combinesWithFollowingClassRange(expression, classRange) {
|
|
if (classRange && classRange.type === 'ClassRange') {
|
|
// Considering the elements were ordered alphabetically,
|
|
// there is only one case to handle
|
|
// [ab-e] -> [a-e]
|
|
if (
|
|
// We only want \w chars or char codes to keep readability
|
|
isMetaWCharOrCode(expression) && classRange.from.codePoint === expression.codePoint + 1) {
|
|
classRange.from = expression;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {Object} classRange - ClassRange node
|
|
* @returns {boolean}
|
|
*/
|
|
function fitsInClassRange(expression, classRange) {
|
|
if (expression.type === 'Char' && isNaN(expression.codePoint)) {
|
|
return false;
|
|
}
|
|
if (expression.type === 'ClassRange') {
|
|
return fitsInClassRange(expression.from, classRange) && fitsInClassRange(expression.to, classRange);
|
|
}
|
|
return expression.codePoint >= classRange.from.codePoint && expression.codePoint <= classRange.to.codePoint;
|
|
}
|
|
|
|
/**
|
|
* @param {Object} expression - Char or ClassRange node
|
|
* @param {Number} index
|
|
* @param {Object[]} expressions - expressions in CharClass
|
|
* @returns {number} - Number of characters combined with expression
|
|
*/
|
|
function charCombinesWithPrecedingChars(expression, index, expressions) {
|
|
// We only want \w chars or char codes to keep readability
|
|
if (!isMetaWCharOrCode(expression)) {
|
|
return 0;
|
|
}
|
|
var nbMergedChars = 0;
|
|
while (index > 0) {
|
|
var currentExpression = expressions[index];
|
|
var precedingExpresion = expressions[index - 1];
|
|
if (isMetaWCharOrCode(precedingExpresion) && precedingExpresion.codePoint === currentExpression.codePoint - 1) {
|
|
nbMergedChars++;
|
|
index--;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nbMergedChars > 1) {
|
|
expressions[index] = {
|
|
type: 'ClassRange',
|
|
from: expressions[index],
|
|
to: expression
|
|
};
|
|
return nbMergedChars;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
function isMetaWCharOrCode(expression) {
|
|
return expression && expression.type === 'Char' && !isNaN(expression.codePoint) && (fitsInMetaW(expression, false) || expression.kind === 'unicode' || expression.kind === 'hex' || expression.kind === 'oct' || expression.kind === 'decimal');
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var NodePath$1 = nodePath;
|
|
|
|
var _require$7 = utils,
|
|
disjunctionToList = _require$7.disjunctionToList,
|
|
listToDisjunction = _require$7.listToDisjunction;
|
|
|
|
/**
|
|
* Removes duplicates from a disjunction sequence:
|
|
*
|
|
* /(ab|bc|ab)+(xy|xy)+/ -> /(ab|bc)+(xy)+/
|
|
*/
|
|
|
|
|
|
var disjunctionRemoveDuplicatesTransform = {
|
|
Disjunction: function Disjunction(path) {
|
|
var node = path.node;
|
|
|
|
// Make unique nodes.
|
|
|
|
var uniqueNodesMap = {};
|
|
|
|
var parts = disjunctionToList(node).filter(function (part) {
|
|
var encoded = part ? NodePath$1.getForNode(part).jsonEncode() : 'null';
|
|
|
|
// Already recorded this part, filter out.
|
|
if (uniqueNodesMap.hasOwnProperty(encoded)) {
|
|
return false;
|
|
}
|
|
|
|
uniqueNodesMap[encoded] = part;
|
|
return true;
|
|
});
|
|
|
|
// Replace with the optimized disjunction.
|
|
path.replace(listToDisjunction(parts));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to replace single char group disjunction to char group
|
|
*
|
|
* a|b|c -> [abc]
|
|
* [12]|3|4 -> [1234]
|
|
* (a|b|c) -> ([abc])
|
|
* (?:a|b|c) -> [abc]
|
|
*/
|
|
|
|
var groupSingleCharsToCharClass = {
|
|
Disjunction: function Disjunction(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
|
|
if (!handlers[parent.type]) {
|
|
return;
|
|
}
|
|
|
|
var charset = new Map();
|
|
|
|
if (!shouldProcess(node, charset) || !charset.size) {
|
|
return;
|
|
}
|
|
|
|
var characterClass = {
|
|
type: 'CharacterClass',
|
|
expressions: Array.from(charset.keys()).sort().map(function (key) {
|
|
return charset.get(key);
|
|
})
|
|
};
|
|
|
|
handlers[parent.type](path.getParent(), characterClass);
|
|
}
|
|
};
|
|
|
|
var handlers = {
|
|
RegExp: function RegExp(path, characterClass) {
|
|
var node = path.node;
|
|
|
|
|
|
node.body = characterClass;
|
|
},
|
|
Group: function Group(path, characterClass) {
|
|
var node = path.node;
|
|
|
|
|
|
if (node.capturing) {
|
|
node.expression = characterClass;
|
|
} else {
|
|
path.replace(characterClass);
|
|
}
|
|
}
|
|
};
|
|
|
|
function shouldProcess(expression, charset) {
|
|
if (!expression) {
|
|
// Abort on empty disjunction part
|
|
return false;
|
|
}
|
|
|
|
var type = expression.type;
|
|
|
|
|
|
if (type === 'Disjunction') {
|
|
var left = expression.left,
|
|
right = expression.right;
|
|
|
|
|
|
return shouldProcess(left, charset) && shouldProcess(right, charset);
|
|
} else if (type === 'Char') {
|
|
if (expression.kind === 'meta' && expression.symbol === '.') {
|
|
return false;
|
|
}
|
|
|
|
var value = expression.value;
|
|
|
|
|
|
charset.set(value, expression);
|
|
|
|
return true;
|
|
} else if (type === 'CharacterClass' && !expression.negative) {
|
|
return expression.expressions.every(function (expression) {
|
|
return shouldProcess(expression, charset);
|
|
});
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to remove non-capturing empty groups.
|
|
*
|
|
* /(?:)a/ -> /a/
|
|
* /a|(?:)/ -> /a|/
|
|
*/
|
|
|
|
var removeEmptyGroupTransform = {
|
|
Group: function Group(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
var childPath = path.getChild();
|
|
|
|
if (node.capturing || childPath) {
|
|
return;
|
|
}
|
|
|
|
if (parent.type === 'Repetition') {
|
|
|
|
path.getParent().replace(node);
|
|
} else if (parent.type !== 'RegExp') {
|
|
|
|
path.remove();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A regexp-tree plugin to remove unnecessary groups.
|
|
*
|
|
* /(?:a)/ -> /a/
|
|
*/
|
|
|
|
function _toConsumableArray$5(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var ungroupTransform = {
|
|
Group: function Group(path) {
|
|
var node = path.node,
|
|
parent = path.parent;
|
|
|
|
var childPath = path.getChild();
|
|
|
|
if (node.capturing || !childPath) {
|
|
return;
|
|
}
|
|
|
|
// Don't optimize \1(?:0) to \10
|
|
if (!hasAppropriateSiblings(path)) {
|
|
return;
|
|
}
|
|
|
|
// Don't optimize /a(?:b|c)/ to /ab|c/
|
|
// but /(?:b|c)/ to /b|c/ is ok
|
|
if (childPath.node.type === 'Disjunction' && parent.type !== 'RegExp') {
|
|
return;
|
|
}
|
|
|
|
// Don't optimize /(?:ab)+/ to /ab+/
|
|
// but /(?:a)+/ to /a+/ is ok
|
|
// and /(?:[a-d])+/ to /[a-d]+/ is ok too
|
|
if (parent.type === 'Repetition' && childPath.node.type !== 'Char' && childPath.node.type !== 'CharacterClass') {
|
|
return;
|
|
}
|
|
|
|
if (childPath.node.type === 'Alternative') {
|
|
var parentPath = path.getParent();
|
|
if (parentPath.node.type === 'Alternative') {
|
|
// /abc(?:def)ghi/ When (?:def) is ungrouped its content must be merged with parent alternative
|
|
|
|
parentPath.replace({
|
|
type: 'Alternative',
|
|
expressions: [].concat(_toConsumableArray$5(parent.expressions.slice(0, path.index)), _toConsumableArray$5(childPath.node.expressions), _toConsumableArray$5(parent.expressions.slice(path.index + 1)))
|
|
});
|
|
}
|
|
} else {
|
|
path.replace(childPath.node);
|
|
}
|
|
}
|
|
};
|
|
|
|
function hasAppropriateSiblings(path) {
|
|
var parent = path.parent,
|
|
index = path.index;
|
|
|
|
|
|
if (parent.type !== 'Alternative') {
|
|
return true;
|
|
}
|
|
|
|
var previousNode = parent.expressions[index - 1];
|
|
if (previousNode == null) {
|
|
return true;
|
|
}
|
|
|
|
// Don't optimized \1(?:0) to \10
|
|
if (previousNode.type === 'Backreference' && previousNode.kind === 'number') {
|
|
return false;
|
|
}
|
|
|
|
// Don't optimized \2(?:0) to \20
|
|
if (previousNode.type === 'Char' && previousNode.kind === 'decimal') {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
function _toConsumableArray$4(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var NodePath = nodePath;
|
|
|
|
var _require$6 = utils,
|
|
increaseQuantifierByOne = _require$6.increaseQuantifierByOne;
|
|
|
|
/**
|
|
* A regexp-tree plugin to combine repeating patterns.
|
|
*
|
|
* /^abcabcabc/ -> /^abc{3}/
|
|
* /^(?:abc){2}abc/ -> /^(?:abc){3}/
|
|
* /^abc(?:abc){2}/ -> /^(?:abc){3}/
|
|
*/
|
|
|
|
var combineRepeatingPatternsTransform = {
|
|
Alternative: function Alternative(path) {
|
|
var node = path.node;
|
|
|
|
// We can skip the first child
|
|
|
|
var index = 1;
|
|
while (index < node.expressions.length) {
|
|
var child = path.getChild(index);
|
|
index = Math.max(1, combineRepeatingPatternLeft(path, child, index));
|
|
|
|
if (index >= node.expressions.length) {
|
|
break;
|
|
}
|
|
|
|
child = path.getChild(index);
|
|
index = Math.max(1, combineWithPreviousRepetition(path, child, index));
|
|
|
|
if (index >= node.expressions.length) {
|
|
break;
|
|
}
|
|
|
|
child = path.getChild(index);
|
|
index = Math.max(1, combineRepetitionWithPrevious(path, child, index));
|
|
|
|
index++;
|
|
}
|
|
}
|
|
};
|
|
|
|
// abcabc -> (?:abc){2}
|
|
function combineRepeatingPatternLeft(alternative, child, index) {
|
|
var node = alternative.node;
|
|
|
|
|
|
var nbPossibleLengths = Math.ceil(index / 2);
|
|
var i = 0;
|
|
|
|
while (i < nbPossibleLengths) {
|
|
var startIndex = index - 2 * i - 1;
|
|
var right = void 0,
|
|
left = void 0;
|
|
|
|
if (i === 0) {
|
|
right = child;
|
|
left = alternative.getChild(startIndex);
|
|
} else {
|
|
right = NodePath.getForNode({
|
|
type: 'Alternative',
|
|
expressions: [].concat(_toConsumableArray$4(node.expressions.slice(index - i, index)), [child.node])
|
|
});
|
|
|
|
left = NodePath.getForNode({
|
|
type: 'Alternative',
|
|
expressions: [].concat(_toConsumableArray$4(node.expressions.slice(startIndex, index - i)))
|
|
});
|
|
}
|
|
|
|
if (right.hasEqualSource(left)) {
|
|
for (var j = 0; j < 2 * i + 1; j++) {
|
|
alternative.getChild(startIndex).remove();
|
|
}
|
|
|
|
child.replace({
|
|
type: 'Repetition',
|
|
expression: i === 0 && right.node.type !== 'Repetition' ? right.node : {
|
|
type: 'Group',
|
|
capturing: false,
|
|
expression: right.node
|
|
},
|
|
quantifier: {
|
|
type: 'Quantifier',
|
|
kind: 'Range',
|
|
from: 2,
|
|
to: 2,
|
|
greedy: true
|
|
}
|
|
});
|
|
return startIndex;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// (?:abc){2}abc -> (?:abc){3}
|
|
function combineWithPreviousRepetition(alternative, child, index) {
|
|
var node = alternative.node;
|
|
|
|
|
|
var i = 0;
|
|
while (i < index) {
|
|
var previousChild = alternative.getChild(i);
|
|
|
|
if (previousChild.node.type === 'Repetition' && previousChild.node.quantifier.greedy) {
|
|
var left = previousChild.getChild();
|
|
var right = void 0;
|
|
|
|
if (left.node.type === 'Group' && !left.node.capturing) {
|
|
left = left.getChild();
|
|
}
|
|
|
|
if (i + 1 === index) {
|
|
right = child;
|
|
if (right.node.type === 'Group' && !right.node.capturing) {
|
|
right = right.getChild();
|
|
}
|
|
} else {
|
|
right = NodePath.getForNode({
|
|
type: 'Alternative',
|
|
expressions: [].concat(_toConsumableArray$4(node.expressions.slice(i + 1, index + 1)))
|
|
});
|
|
}
|
|
|
|
if (left.hasEqualSource(right)) {
|
|
for (var j = i; j < index; j++) {
|
|
alternative.getChild(i + 1).remove();
|
|
}
|
|
|
|
increaseQuantifierByOne(previousChild.node.quantifier);
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
// abc(?:abc){2} -> (?:abc){3}
|
|
function combineRepetitionWithPrevious(alternative, child, index) {
|
|
var node = alternative.node;
|
|
|
|
|
|
if (child.node.type === 'Repetition' && child.node.quantifier.greedy) {
|
|
var right = child.getChild();
|
|
var left = void 0;
|
|
|
|
if (right.node.type === 'Group' && !right.node.capturing) {
|
|
right = right.getChild();
|
|
}
|
|
|
|
var rightLength = void 0;
|
|
if (right.node.type === 'Alternative') {
|
|
rightLength = right.node.expressions.length;
|
|
left = NodePath.getForNode({
|
|
type: 'Alternative',
|
|
expressions: [].concat(_toConsumableArray$4(node.expressions.slice(index - rightLength, index)))
|
|
});
|
|
} else {
|
|
rightLength = 1;
|
|
left = alternative.getChild(index - 1);
|
|
if (left.node.type === 'Group' && !left.node.capturing) {
|
|
left = left.getChild();
|
|
}
|
|
}
|
|
|
|
if (left.hasEqualSource(right)) {
|
|
for (var j = index - rightLength; j < index; j++) {
|
|
alternative.getChild(index - rightLength).remove();
|
|
}
|
|
|
|
increaseQuantifierByOne(child.node.quantifier);
|
|
|
|
return index - rightLength;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var transforms = new Map([
|
|
// \ud83d\ude80 -> \u{1f680}
|
|
['charSurrogatePairToSingleUnicode', charSurrogatePairToSingleUnicodeTransform],
|
|
|
|
// \u0061 -> a
|
|
['charCodeToSimpleChar', charCodeToSimpleCharTransform],
|
|
|
|
// /Aa/i -> /aa/i
|
|
['charCaseInsensitiveLowerCaseTransform', charCaseInsensitiveLowercaseTransform],
|
|
|
|
// [\d\d] -> [\d]
|
|
['charClassRemoveDuplicates', charClassRemoveDuplicatesTransform],
|
|
|
|
// a{1,2}a{2,3} -> a{3,5}
|
|
['quantifiersMerge', quantifiersMergeTransform],
|
|
|
|
// a{1,} -> a+, a{3,3} -> a{3}, a{1} -> a
|
|
['quantifierRangeToSymbol', quantifierRangeToSymbolTransform],
|
|
|
|
// [a-a] -> [a], [a-b] -> [ab]
|
|
['charClassClassrangesToChars', charClassClassrangesToCharsTransform],
|
|
|
|
// [0-9] -> [\d]
|
|
['charClassToMeta', charClassToMetaTransform],
|
|
|
|
// [\d] -> \d, [^\w] -> \W
|
|
['charClassToSingleChar', charClassToSingleCharTransform],
|
|
|
|
// \e -> e
|
|
['charEscapeUnescape', charEscapeUnescapeTransform],
|
|
|
|
// [a-de-f] -> [a-f]
|
|
['charClassClassrangesMerge', charClassClassrangesMergeTransform],
|
|
|
|
// (ab|ab) -> (ab)
|
|
['disjunctionRemoveDuplicates', disjunctionRemoveDuplicatesTransform],
|
|
|
|
// (a|b|c) -> [abc]
|
|
['groupSingleCharsToCharClass', groupSingleCharsToCharClass],
|
|
|
|
// (?:)a -> a
|
|
['removeEmptyGroup', removeEmptyGroupTransform],
|
|
|
|
// (?:a) -> a
|
|
['ungroup', ungroupTransform],
|
|
|
|
// abcabcabc -> (?:abc){3}
|
|
['combineRepeatingPatterns', combineRepeatingPatternsTransform]]);
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var clone = clone$1;
|
|
var parser$2 = parser$4;
|
|
var transform = transform$1;
|
|
var optimizationTransforms = transforms;
|
|
|
|
var optimizer$1 = {
|
|
/**
|
|
* Optimizer transforms a regular expression into an optimized version,
|
|
* replacing some sub-expressions with their idiomatic patterns.
|
|
*
|
|
* @param string | RegExp | AST - a regexp to optimize.
|
|
*
|
|
* @return TransformResult - an optimized regexp.
|
|
*
|
|
* Example:
|
|
*
|
|
* /[a-zA-Z_0-9][a-zA-Z_0-9]*\e{1,}/
|
|
*
|
|
* Optimized to:
|
|
*
|
|
* /\w+e+/
|
|
*/
|
|
optimize: function optimize(regexp) {
|
|
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
|
_ref$whitelist = _ref.whitelist,
|
|
whitelist = _ref$whitelist === undefined ? [] : _ref$whitelist,
|
|
_ref$blacklist = _ref.blacklist,
|
|
blacklist = _ref$blacklist === undefined ? [] : _ref$blacklist;
|
|
|
|
var transformsRaw = whitelist.length > 0 ? whitelist : Array.from(optimizationTransforms.keys());
|
|
|
|
var transformToApply = transformsRaw.filter(function (transform) {
|
|
return !blacklist.includes(transform);
|
|
});
|
|
|
|
var ast = regexp;
|
|
if (regexp instanceof RegExp) {
|
|
regexp = '' + regexp;
|
|
}
|
|
|
|
if (typeof regexp === 'string') {
|
|
ast = parser$2.parse(regexp);
|
|
}
|
|
|
|
var result = new transform.TransformResult(ast);
|
|
var prevResultString = void 0;
|
|
|
|
do {
|
|
// Get a copy of the current state here so
|
|
// we can compare it with the state at the
|
|
// end of the loop.
|
|
prevResultString = result.toString();
|
|
ast = clone(result.getAST());
|
|
|
|
transformToApply.forEach(function (transformName) {
|
|
if (!optimizationTransforms.has(transformName)) {
|
|
throw new Error('Unknown optimization-transform: ' + transformName + '. ' + 'Available transforms are: ' + Array.from(optimizationTransforms.keys()).join(', '));
|
|
}
|
|
|
|
var transformer = optimizationTransforms.get(transformName);
|
|
|
|
// Don't override result just yet since we
|
|
// might want to rollback the transform
|
|
var newResult = transform.transform(ast, transformer);
|
|
|
|
if (newResult.toString() !== result.toString()) {
|
|
if (newResult.toString().length <= result.toString().length) {
|
|
result = newResult;
|
|
} else {
|
|
// Result has changed but is not shorter:
|
|
// restore ast to its previous state.
|
|
|
|
ast = clone(result.getAST());
|
|
}
|
|
}
|
|
});
|
|
|
|
// Keep running the optimizer until it stops
|
|
// making any change to the regexp.
|
|
} while (result.toString() !== prevResultString);
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* Epsilon, the empty string.
|
|
*/
|
|
|
|
var EPSILON$3 = 'ε';
|
|
|
|
/**
|
|
* Epsilon-closure.
|
|
*/
|
|
var EPSILON_CLOSURE$2 = EPSILON$3 + '*';
|
|
|
|
var specialSymbols = {
|
|
EPSILON: EPSILON$3,
|
|
EPSILON_CLOSURE: EPSILON_CLOSURE$2
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _slicedToArray$1 = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
var _createClass$4 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _toConsumableArray$3(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
function _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var _require$5 = specialSymbols,
|
|
EPSILON$2 = _require$5.EPSILON,
|
|
EPSILON_CLOSURE$1 = _require$5.EPSILON_CLOSURE;
|
|
|
|
/**
|
|
* NFA fragment.
|
|
*
|
|
* NFA sub-fragments can be combined to a larger NFAs building
|
|
* the resulting machine. Combining the fragments is done by patching
|
|
* edges of the in- and out-states.
|
|
*
|
|
* 2-states implementation, `in`, and `out`. Eventually all transitions
|
|
* go to the same `out`, which can further be connected via ε-transition
|
|
* with other fragment.
|
|
*/
|
|
|
|
|
|
var NFA$2 = function () {
|
|
function NFA(inState, outState) {
|
|
_classCallCheck$4(this, NFA);
|
|
|
|
this.in = inState;
|
|
this.out = outState;
|
|
}
|
|
|
|
/**
|
|
* Tries to recognize a string based on this NFA fragment.
|
|
*/
|
|
|
|
|
|
_createClass$4(NFA, [{
|
|
key: 'matches',
|
|
value: function matches(string) {
|
|
return this.in.matches(string);
|
|
}
|
|
|
|
/**
|
|
* Returns an alphabet for this NFA.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getAlphabet',
|
|
value: function getAlphabet() {
|
|
if (!this._alphabet) {
|
|
this._alphabet = new Set();
|
|
var table = this.getTransitionTable();
|
|
for (var state in table) {
|
|
var transitions = table[state];
|
|
for (var symbol in transitions) {
|
|
if (symbol !== EPSILON_CLOSURE$1) {
|
|
this._alphabet.add(symbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this._alphabet;
|
|
}
|
|
|
|
/**
|
|
* Returns set of accepting states.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getAcceptingStates',
|
|
value: function getAcceptingStates() {
|
|
if (!this._acceptingStates) {
|
|
// States are determined during table construction.
|
|
this.getTransitionTable();
|
|
}
|
|
return this._acceptingStates;
|
|
}
|
|
|
|
/**
|
|
* Returns accepting state numbers.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getAcceptingStateNumbers',
|
|
value: function getAcceptingStateNumbers() {
|
|
if (!this._acceptingStateNumbers) {
|
|
this._acceptingStateNumbers = new Set();
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = this.getAcceptingStates()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var acceptingState = _step.value;
|
|
|
|
this._acceptingStateNumbers.add(acceptingState.number);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return this._acceptingStateNumbers;
|
|
}
|
|
|
|
/**
|
|
* Builds and returns transition table.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getTransitionTable',
|
|
value: function getTransitionTable() {
|
|
var _this = this;
|
|
|
|
if (!this._transitionTable) {
|
|
this._transitionTable = {};
|
|
this._acceptingStates = new Set();
|
|
|
|
var visited = new Set();
|
|
var symbols = new Set();
|
|
|
|
var visitState = function visitState(state) {
|
|
if (visited.has(state)) {
|
|
return;
|
|
}
|
|
|
|
visited.add(state);
|
|
state.number = visited.size;
|
|
_this._transitionTable[state.number] = {};
|
|
|
|
if (state.accepting) {
|
|
_this._acceptingStates.add(state);
|
|
}
|
|
|
|
var transitions = state.getTransitions();
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = transitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var _ref = _step2.value;
|
|
|
|
var _ref2 = _slicedToArray$1(_ref, 2);
|
|
|
|
var symbol = _ref2[0];
|
|
var symbolTransitions = _ref2[1];
|
|
|
|
var combinedState = [];
|
|
symbols.add(symbol);
|
|
var _iteratorNormalCompletion3 = true;
|
|
var _didIteratorError3 = false;
|
|
var _iteratorError3 = undefined;
|
|
|
|
try {
|
|
for (var _iterator3 = symbolTransitions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
|
var nextState = _step3.value;
|
|
|
|
visitState(nextState);
|
|
combinedState.push(nextState.number);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError3 = true;
|
|
_iteratorError3 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion3 && _iterator3.return) {
|
|
_iterator3.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError3) {
|
|
throw _iteratorError3;
|
|
}
|
|
}
|
|
}
|
|
|
|
_this._transitionTable[state.number][symbol] = combinedState;
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Traverse the graph starting from the `in`.
|
|
visitState(this.in);
|
|
|
|
// Append epsilon-closure column.
|
|
visited.forEach(function (state) {
|
|
delete _this._transitionTable[state.number][EPSILON$2];
|
|
_this._transitionTable[state.number][EPSILON_CLOSURE$1] = [].concat(_toConsumableArray$3(state.getEpsilonClosure())).map(function (s) {
|
|
return s.number;
|
|
});
|
|
});
|
|
}
|
|
|
|
return this._transitionTable;
|
|
}
|
|
}]);
|
|
|
|
return NFA;
|
|
}();
|
|
|
|
var nfa = NFA$2;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
// DFA minization.
|
|
|
|
/**
|
|
* Map from state to current set it goes.
|
|
*/
|
|
|
|
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
|
|
|
|
function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
|
|
|
|
function _toConsumableArray$2(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var currentTransitionMap = null;
|
|
|
|
/**
|
|
* Takes a DFA, and returns a minimized version of it
|
|
* compressing some states to groups (using standard, 0-, 1-,
|
|
* 2-, ... N-equivalence algorithm).
|
|
*/
|
|
function minimize(dfa) {
|
|
var table = dfa.getTransitionTable();
|
|
var allStates = Object.keys(table);
|
|
var alphabet = dfa.getAlphabet();
|
|
var accepting = dfa.getAcceptingStateNumbers();
|
|
|
|
currentTransitionMap = {};
|
|
|
|
var nonAccepting = new Set();
|
|
|
|
allStates.forEach(function (state) {
|
|
state = Number(state);
|
|
var isAccepting = accepting.has(state);
|
|
|
|
if (isAccepting) {
|
|
currentTransitionMap[state] = accepting;
|
|
} else {
|
|
nonAccepting.add(state);
|
|
currentTransitionMap[state] = nonAccepting;
|
|
}
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Step 1: build equivalent sets.
|
|
|
|
// All [1..N] equivalent sets.
|
|
var all = [
|
|
// 0-equivalent sets.
|
|
[nonAccepting, accepting].filter(function (set) {
|
|
return set.size > 0;
|
|
})];
|
|
|
|
var current = void 0;
|
|
var previous = void 0;
|
|
|
|
// Top of the stack is the current list of sets to analyze.
|
|
current = all[all.length - 1];
|
|
|
|
// Previous set (to check whether we need to stop).
|
|
previous = all[all.length - 2];
|
|
|
|
// Until we'll not have the same N and N-1 equivalent rows.
|
|
|
|
var _loop = function _loop() {
|
|
var newTransitionMap = {};
|
|
|
|
var _iteratorNormalCompletion3 = true;
|
|
var _didIteratorError3 = false;
|
|
var _iteratorError3 = undefined;
|
|
|
|
try {
|
|
for (var _iterator3 = current[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
|
var _set = _step3.value;
|
|
|
|
// Handled states for this set.
|
|
var handledStates = {};
|
|
|
|
var _set2 = _toArray(_set),
|
|
first = _set2[0],
|
|
rest = _set2.slice(1);
|
|
|
|
handledStates[first] = new Set([first]);
|
|
|
|
// Have to compare each from the rest states with
|
|
// the already handled states, and see if they are equivalent.
|
|
var _iteratorNormalCompletion4 = true;
|
|
var _didIteratorError4 = false;
|
|
var _iteratorError4 = undefined;
|
|
|
|
try {
|
|
restSets: for (var _iterator4 = rest[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
|
var state = _step4.value;
|
|
var _iteratorNormalCompletion5 = true;
|
|
var _didIteratorError5 = false;
|
|
var _iteratorError5 = undefined;
|
|
|
|
try {
|
|
for (var _iterator5 = Object.keys(handledStates)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
|
|
var handledState = _step5.value;
|
|
|
|
// This and some previously handled state are equivalent --
|
|
// just append this state to the same set.
|
|
if (areEquivalent(state, handledState, table, alphabet)) {
|
|
handledStates[handledState].add(state);
|
|
handledStates[state] = handledStates[handledState];
|
|
continue restSets;
|
|
}
|
|
}
|
|
// Else, this state is not equivalent to any of the
|
|
// handled states -- allocate a new set for it.
|
|
} catch (err) {
|
|
_didIteratorError5 = true;
|
|
_iteratorError5 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion5 && _iterator5.return) {
|
|
_iterator5.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError5) {
|
|
throw _iteratorError5;
|
|
}
|
|
}
|
|
}
|
|
|
|
handledStates[state] = new Set([state]);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError4 = true;
|
|
_iteratorError4 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion4 && _iterator4.return) {
|
|
_iterator4.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError4) {
|
|
throw _iteratorError4;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add these handled states to all states map.
|
|
|
|
|
|
Object.assign(newTransitionMap, handledStates);
|
|
}
|
|
|
|
// Update current transition map for the handled row.
|
|
} catch (err) {
|
|
_didIteratorError3 = true;
|
|
_iteratorError3 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion3 && _iterator3.return) {
|
|
_iterator3.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError3) {
|
|
throw _iteratorError3;
|
|
}
|
|
}
|
|
}
|
|
|
|
currentTransitionMap = newTransitionMap;
|
|
|
|
var newSets = new Set(Object.keys(newTransitionMap).map(function (state) {
|
|
return newTransitionMap[state];
|
|
}));
|
|
|
|
all.push([].concat(_toConsumableArray$2(newSets)));
|
|
|
|
// Top of the stack is the current.
|
|
current = all[all.length - 1];
|
|
|
|
// Previous set.
|
|
previous = all[all.length - 2];
|
|
};
|
|
|
|
while (!sameRow(current, previous)) {
|
|
_loop();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Step 2: build minimized table from the equivalent sets.
|
|
|
|
// Remap state numbers from sets to index-based.
|
|
var remaped = new Map();
|
|
var idx = 1;
|
|
current.forEach(function (set) {
|
|
return remaped.set(set, idx++);
|
|
});
|
|
|
|
// Build the minimized table from the calculated equivalent sets.
|
|
var minimizedTable = {};
|
|
|
|
var minimizedAcceptingStates = new Set();
|
|
|
|
var updateAcceptingStates = function updateAcceptingStates(set, idx) {
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = set[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var state = _step.value;
|
|
|
|
if (accepting.has(state)) {
|
|
minimizedAcceptingStates.add(idx);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = remaped.entries()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var _ref = _step2.value;
|
|
|
|
var _ref2 = _slicedToArray(_ref, 2);
|
|
|
|
var set = _ref2[0];
|
|
var _idx = _ref2[1];
|
|
|
|
minimizedTable[_idx] = {};
|
|
var _iteratorNormalCompletion6 = true;
|
|
var _didIteratorError6 = false;
|
|
var _iteratorError6 = undefined;
|
|
|
|
try {
|
|
for (var _iterator6 = alphabet[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
|
|
var symbol = _step6.value;
|
|
|
|
updateAcceptingStates(set, _idx);
|
|
|
|
// Determine original transition for this symbol from the set.
|
|
var originalTransition = void 0;
|
|
var _iteratorNormalCompletion7 = true;
|
|
var _didIteratorError7 = false;
|
|
var _iteratorError7 = undefined;
|
|
|
|
try {
|
|
for (var _iterator7 = set[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
|
|
var originalState = _step7.value;
|
|
|
|
originalTransition = table[originalState][symbol];
|
|
if (originalTransition) {
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError7 = true;
|
|
_iteratorError7 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion7 && _iterator7.return) {
|
|
_iterator7.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError7) {
|
|
throw _iteratorError7;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (originalTransition) {
|
|
minimizedTable[_idx][symbol] = remaped.get(currentTransitionMap[originalTransition]);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError6 = true;
|
|
_iteratorError6 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion6 && _iterator6.return) {
|
|
_iterator6.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError6) {
|
|
throw _iteratorError6;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update the table, and accepting states on the original DFA.
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
|
|
dfa.setTransitionTable(minimizedTable);
|
|
dfa.setAcceptingStateNumbers(minimizedAcceptingStates);
|
|
|
|
return dfa;
|
|
}
|
|
|
|
function sameRow(r1, r2) {
|
|
if (!r2) {
|
|
return false;
|
|
}
|
|
|
|
if (r1.length !== r2.length) {
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0; i < r1.length; i++) {
|
|
var s1 = r1[i];
|
|
var s2 = r2[i];
|
|
|
|
if (s1.size !== s2.size) {
|
|
return false;
|
|
}
|
|
|
|
if ([].concat(_toConsumableArray$2(s1)).sort().join(',') !== [].concat(_toConsumableArray$2(s2)).sort().join(',')) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks whether two states are N-equivalent, i.e. whether they go
|
|
* to the same set on a symbol.
|
|
*/
|
|
function areEquivalent(s1, s2, table, alphabet) {
|
|
var _iteratorNormalCompletion8 = true;
|
|
var _didIteratorError8 = false;
|
|
var _iteratorError8 = undefined;
|
|
|
|
try {
|
|
for (var _iterator8 = alphabet[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
|
|
var symbol = _step8.value;
|
|
|
|
if (!goToSameSet(s1, s2, table, symbol)) {
|
|
return false;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError8 = true;
|
|
_iteratorError8 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion8 && _iterator8.return) {
|
|
_iterator8.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError8) {
|
|
throw _iteratorError8;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks whether states go to the same set.
|
|
*/
|
|
function goToSameSet(s1, s2, table, symbol) {
|
|
if (!currentTransitionMap[s1] || !currentTransitionMap[s2]) {
|
|
return false;
|
|
}
|
|
|
|
var originalTransitionS1 = table[s1][symbol];
|
|
var originalTransitionS2 = table[s2][symbol];
|
|
|
|
// If no actual transition on this symbol, treat it as positive.
|
|
if (!originalTransitionS1 && !originalTransitionS2) {
|
|
return true;
|
|
}
|
|
|
|
// Otherwise, check if they are in the same sets.
|
|
return currentTransitionMap[s1].has(originalTransitionS1) && currentTransitionMap[s2].has(originalTransitionS2);
|
|
}
|
|
|
|
var dfaMinimizer = {
|
|
minimize: minimize
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _createClass$3 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _toConsumableArray$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var DFAMinimizer = dfaMinimizer;
|
|
|
|
var _require$4 = specialSymbols,
|
|
EPSILON_CLOSURE = _require$4.EPSILON_CLOSURE;
|
|
|
|
/**
|
|
* DFA is build by converting from NFA (subset construction).
|
|
*/
|
|
|
|
|
|
var DFA$1 = function () {
|
|
function DFA(nfa) {
|
|
_classCallCheck$3(this, DFA);
|
|
|
|
this._nfa = nfa;
|
|
}
|
|
|
|
/**
|
|
* Minimizes DFA.
|
|
*/
|
|
|
|
|
|
_createClass$3(DFA, [{
|
|
key: 'minimize',
|
|
value: function minimize() {
|
|
this.getTransitionTable();
|
|
|
|
this._originalAcceptingStateNumbers = this._acceptingStateNumbers;
|
|
this._originalTransitionTable = this._transitionTable;
|
|
|
|
DFAMinimizer.minimize(this);
|
|
}
|
|
|
|
/**
|
|
* Returns alphabet for this DFA.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getAlphabet',
|
|
value: function getAlphabet() {
|
|
return this._nfa.getAlphabet();
|
|
}
|
|
|
|
/**
|
|
* Returns accepting states.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getAcceptingStateNumbers',
|
|
value: function getAcceptingStateNumbers() {
|
|
if (!this._acceptingStateNumbers) {
|
|
// Accepting states are determined during table construction.
|
|
this.getTransitionTable();
|
|
}
|
|
|
|
return this._acceptingStateNumbers;
|
|
}
|
|
|
|
/**
|
|
* Returns original accepting states.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getOriginaAcceptingStateNumbers',
|
|
value: function getOriginaAcceptingStateNumbers() {
|
|
if (!this._originalAcceptingStateNumbers) {
|
|
// Accepting states are determined during table construction.
|
|
this.getTransitionTable();
|
|
}
|
|
|
|
return this._originalAcceptingStateNumbers;
|
|
}
|
|
|
|
/**
|
|
* Sets transition table.
|
|
*/
|
|
|
|
}, {
|
|
key: 'setTransitionTable',
|
|
value: function setTransitionTable(table) {
|
|
this._transitionTable = table;
|
|
}
|
|
|
|
/**
|
|
* Sets accepting states.
|
|
*/
|
|
|
|
}, {
|
|
key: 'setAcceptingStateNumbers',
|
|
value: function setAcceptingStateNumbers(stateNumbers) {
|
|
this._acceptingStateNumbers = stateNumbers;
|
|
}
|
|
|
|
/**
|
|
* DFA transition table is built from NFA table.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getTransitionTable',
|
|
value: function getTransitionTable() {
|
|
var _this = this;
|
|
|
|
if (this._transitionTable) {
|
|
return this._transitionTable;
|
|
}
|
|
|
|
// Calculate from NFA transition table.
|
|
var nfaTable = this._nfa.getTransitionTable();
|
|
var nfaStates = Object.keys(nfaTable);
|
|
|
|
this._acceptingStateNumbers = new Set();
|
|
|
|
// Start state of DFA is E(S[nfa])
|
|
var startState = nfaTable[nfaStates[0]][EPSILON_CLOSURE];
|
|
|
|
// Init the worklist (states which should be in the DFA).
|
|
var worklist = [startState];
|
|
|
|
var alphabet = this.getAlphabet();
|
|
var nfaAcceptingStates = this._nfa.getAcceptingStateNumbers();
|
|
|
|
var dfaTable = {};
|
|
|
|
// Determine whether the combined DFA state is accepting.
|
|
var updateAcceptingStates = function updateAcceptingStates(states) {
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = nfaAcceptingStates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var nfaAcceptingState = _step.value;
|
|
|
|
// If any of the states from NFA is accepting, DFA's
|
|
// state is accepting as well.
|
|
if (states.indexOf(nfaAcceptingState) !== -1) {
|
|
_this._acceptingStateNumbers.add(states.join(','));
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
while (worklist.length > 0) {
|
|
var states = worklist.shift();
|
|
var dfaStateLabel = states.join(',');
|
|
dfaTable[dfaStateLabel] = {};
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = alphabet[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var symbol = _step2.value;
|
|
|
|
var onSymbol = [];
|
|
|
|
// Determine whether the combined state is accepting.
|
|
updateAcceptingStates(states);
|
|
|
|
var _iteratorNormalCompletion3 = true;
|
|
var _didIteratorError3 = false;
|
|
var _iteratorError3 = undefined;
|
|
|
|
try {
|
|
for (var _iterator3 = states[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
|
var state = _step3.value;
|
|
|
|
var nfaStatesOnSymbol = nfaTable[state][symbol];
|
|
if (!nfaStatesOnSymbol) {
|
|
continue;
|
|
}
|
|
|
|
var _iteratorNormalCompletion4 = true;
|
|
var _didIteratorError4 = false;
|
|
var _iteratorError4 = undefined;
|
|
|
|
try {
|
|
for (var _iterator4 = nfaStatesOnSymbol[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
|
var nfaStateOnSymbol = _step4.value;
|
|
|
|
if (!nfaTable[nfaStateOnSymbol]) {
|
|
continue;
|
|
}
|
|
onSymbol.push.apply(onSymbol, _toConsumableArray$1(nfaTable[nfaStateOnSymbol][EPSILON_CLOSURE]));
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError4 = true;
|
|
_iteratorError4 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion4 && _iterator4.return) {
|
|
_iterator4.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError4) {
|
|
throw _iteratorError4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError3 = true;
|
|
_iteratorError3 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion3 && _iterator3.return) {
|
|
_iterator3.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError3) {
|
|
throw _iteratorError3;
|
|
}
|
|
}
|
|
}
|
|
|
|
var dfaStatesOnSymbolSet = new Set(onSymbol);
|
|
var dfaStatesOnSymbol = [].concat(_toConsumableArray$1(dfaStatesOnSymbolSet));
|
|
|
|
if (dfaStatesOnSymbol.length > 0) {
|
|
var dfaOnSymbolStr = dfaStatesOnSymbol.join(',');
|
|
|
|
dfaTable[dfaStateLabel][symbol] = dfaOnSymbolStr;
|
|
|
|
if (!dfaTable.hasOwnProperty(dfaOnSymbolStr)) {
|
|
worklist.unshift(dfaStatesOnSymbol);
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this._transitionTable = this._remapStateNumbers(dfaTable);
|
|
}
|
|
|
|
/**
|
|
* Remaps state numbers in the resulting table:
|
|
* combined states '1,2,3' -> 1, '3,4' -> 2, etc.
|
|
*/
|
|
|
|
}, {
|
|
key: '_remapStateNumbers',
|
|
value: function _remapStateNumbers(calculatedDFATable) {
|
|
var newStatesMap = {};
|
|
|
|
this._originalTransitionTable = calculatedDFATable;
|
|
var transitionTable = {};
|
|
|
|
Object.keys(calculatedDFATable).forEach(function (originalNumber, newNumber) {
|
|
newStatesMap[originalNumber] = newNumber + 1;
|
|
});
|
|
|
|
for (var originalNumber in calculatedDFATable) {
|
|
var originalRow = calculatedDFATable[originalNumber];
|
|
var row = {};
|
|
|
|
for (var symbol in originalRow) {
|
|
row[symbol] = newStatesMap[originalRow[symbol]];
|
|
}
|
|
|
|
transitionTable[newStatesMap[originalNumber]] = row;
|
|
}
|
|
|
|
// Remap accepting states.
|
|
this._originalAcceptingStateNumbers = this._acceptingStateNumbers;
|
|
this._acceptingStateNumbers = new Set();
|
|
|
|
var _iteratorNormalCompletion5 = true;
|
|
var _didIteratorError5 = false;
|
|
var _iteratorError5 = undefined;
|
|
|
|
try {
|
|
for (var _iterator5 = this._originalAcceptingStateNumbers[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
|
|
var _originalNumber = _step5.value;
|
|
|
|
this._acceptingStateNumbers.add(newStatesMap[_originalNumber]);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError5 = true;
|
|
_iteratorError5 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion5 && _iterator5.return) {
|
|
_iterator5.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError5) {
|
|
throw _iteratorError5;
|
|
}
|
|
}
|
|
}
|
|
|
|
return transitionTable;
|
|
}
|
|
|
|
/**
|
|
* Returns original DFA table, where state numbers
|
|
* are combined numbers from NFA.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getOriginalTransitionTable',
|
|
value: function getOriginalTransitionTable() {
|
|
if (!this._originalTransitionTable) {
|
|
// Original table is determined during table construction.
|
|
this.getTransitionTable();
|
|
}
|
|
return this._originalTransitionTable;
|
|
}
|
|
|
|
/**
|
|
* Checks whether this DFA accepts a string.
|
|
*/
|
|
|
|
}, {
|
|
key: 'matches',
|
|
value: function matches(string) {
|
|
var state = 1;
|
|
var i = 0;
|
|
var table = this.getTransitionTable();
|
|
|
|
while (string[i]) {
|
|
state = table[state][string[i++]];
|
|
if (!state) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!this.getAcceptingStateNumbers().has(state)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}]);
|
|
|
|
return DFA;
|
|
}();
|
|
|
|
var dfa = DFA$1;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* A generic FA State class (base for NFA and DFA).
|
|
*
|
|
* Maintains the transition map, and the flag whether
|
|
* the state is accepting.
|
|
*/
|
|
|
|
var _createClass$2 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var State$1 = function () {
|
|
function State() {
|
|
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
|
|
_ref$accepting = _ref.accepting,
|
|
accepting = _ref$accepting === undefined ? false : _ref$accepting;
|
|
|
|
_classCallCheck$2(this, State);
|
|
|
|
/**
|
|
* Outgoing transitions to other states.
|
|
*/
|
|
this._transitions = new Map();
|
|
|
|
/**
|
|
* Whether the state is accepting.
|
|
*/
|
|
this.accepting = accepting;
|
|
}
|
|
|
|
/**
|
|
* Returns transitions for this state.
|
|
*/
|
|
|
|
|
|
_createClass$2(State, [{
|
|
key: 'getTransitions',
|
|
value: function getTransitions() {
|
|
return this._transitions;
|
|
}
|
|
|
|
/**
|
|
* Creates a transition on symbol.
|
|
*/
|
|
|
|
}, {
|
|
key: 'addTransition',
|
|
value: function addTransition(symbol, toState) {
|
|
this.getTransitionsOnSymbol(symbol).add(toState);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Returns transitions set on symbol.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getTransitionsOnSymbol',
|
|
value: function getTransitionsOnSymbol(symbol) {
|
|
var transitions = this._transitions.get(symbol);
|
|
|
|
if (!transitions) {
|
|
transitions = new Set();
|
|
this._transitions.set(symbol, transitions);
|
|
}
|
|
|
|
return transitions;
|
|
}
|
|
}]);
|
|
|
|
return State;
|
|
}();
|
|
|
|
var state = State$1;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var State = state;
|
|
|
|
var _require$3 = specialSymbols,
|
|
EPSILON$1 = _require$3.EPSILON;
|
|
|
|
/**
|
|
* NFA state.
|
|
*
|
|
* Allows nondeterministic transitions to several states on the
|
|
* same symbol, and also epsilon-transitions.
|
|
*/
|
|
|
|
|
|
var NFAState$1 = function (_State) {
|
|
_inherits(NFAState, _State);
|
|
|
|
function NFAState() {
|
|
_classCallCheck$1(this, NFAState);
|
|
|
|
return _possibleConstructorReturn(this, (NFAState.__proto__ || Object.getPrototypeOf(NFAState)).apply(this, arguments));
|
|
}
|
|
|
|
_createClass$1(NFAState, [{
|
|
key: 'matches',
|
|
|
|
|
|
/**
|
|
* Whether this state matches a string.
|
|
*
|
|
* We maintain set of visited epsilon-states to avoid infinite loops
|
|
* when an epsilon-transition goes eventually to itself.
|
|
*
|
|
* NOTE: this function is rather "educational", since we use DFA for strings
|
|
* matching. DFA is built on top of NFA, and uses fast transition table.
|
|
*/
|
|
value: function matches(string) {
|
|
var visited = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
|
|
|
|
// An epsilon-state has been visited, stop to avoid infinite loop.
|
|
if (visited.has(this)) {
|
|
return false;
|
|
}
|
|
|
|
visited.add(this);
|
|
|
|
// No symbols left..
|
|
if (string.length === 0) {
|
|
// .. and we're in the accepting state.
|
|
if (this.accepting) {
|
|
return true;
|
|
}
|
|
|
|
// Check if we can reach any accepting state from
|
|
// on the epsilon transitions.
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = this.getTransitionsOnSymbol(EPSILON$1)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var nextState = _step.value;
|
|
|
|
if (nextState.matches('', visited)) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Else, we get some symbols.
|
|
var symbol = string[0];
|
|
var rest = string.slice(1);
|
|
|
|
var symbolTransitions = this.getTransitionsOnSymbol(symbol);
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = symbolTransitions[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var _nextState = _step2.value;
|
|
|
|
if (_nextState.matches(rest)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// If we couldn't match on symbol, check still epsilon-transitions
|
|
// without consuming the symbol (i.e. continue from `string`, not `rest`).
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
|
|
var _iteratorNormalCompletion3 = true;
|
|
var _didIteratorError3 = false;
|
|
var _iteratorError3 = undefined;
|
|
|
|
try {
|
|
for (var _iterator3 = this.getTransitionsOnSymbol(EPSILON$1)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
|
var _nextState2 = _step3.value;
|
|
|
|
if (_nextState2.matches(string, visited)) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError3 = true;
|
|
_iteratorError3 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion3 && _iterator3.return) {
|
|
_iterator3.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError3) {
|
|
throw _iteratorError3;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns an ε-closure for this state:
|
|
* self + all states following ε-transitions.
|
|
*/
|
|
|
|
}, {
|
|
key: 'getEpsilonClosure',
|
|
value: function getEpsilonClosure() {
|
|
var _this2 = this;
|
|
|
|
if (!this._epsilonClosure) {
|
|
(function () {
|
|
var epsilonTransitions = _this2.getTransitionsOnSymbol(EPSILON$1);
|
|
var closure = _this2._epsilonClosure = new Set();
|
|
closure.add(_this2);
|
|
var _iteratorNormalCompletion4 = true;
|
|
var _didIteratorError4 = false;
|
|
var _iteratorError4 = undefined;
|
|
|
|
try {
|
|
for (var _iterator4 = epsilonTransitions[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
|
var nextState = _step4.value;
|
|
|
|
if (!closure.has(nextState)) {
|
|
closure.add(nextState);
|
|
var nextClosure = nextState.getEpsilonClosure();
|
|
nextClosure.forEach(function (state) {
|
|
return closure.add(state);
|
|
});
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError4 = true;
|
|
_iteratorError4 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion4 && _iterator4.return) {
|
|
_iterator4.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError4) {
|
|
throw _iteratorError4;
|
|
}
|
|
}
|
|
}
|
|
})();
|
|
}
|
|
|
|
return this._epsilonClosure;
|
|
}
|
|
}]);
|
|
|
|
return NFAState;
|
|
}(State);
|
|
|
|
var nfaState = NFAState$1;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var NFA$1 = nfa;
|
|
var NFAState = nfaState;
|
|
|
|
var _require$2 = specialSymbols,
|
|
EPSILON = _require$2.EPSILON;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Char NFA fragment: `c`
|
|
|
|
/**
|
|
* Char factory.
|
|
*
|
|
* Creates an NFA fragment for a single char.
|
|
*
|
|
* [in] --c--> [out]
|
|
*/
|
|
|
|
|
|
function char$1(c) {
|
|
var inState = new NFAState();
|
|
var outState = new NFAState({
|
|
accepting: true
|
|
});
|
|
|
|
return new NFA$1(inState.addTransition(c, outState), outState);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Epsilon NFA fragment
|
|
|
|
/**
|
|
* Epsilon factory.
|
|
*
|
|
* Creates an NFA fragment for ε (recognizes an empty string).
|
|
*
|
|
* [in] --ε--> [out]
|
|
*/
|
|
function e() {
|
|
return char$1(EPSILON);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Alteration NFA fragment: `abc`
|
|
|
|
/**
|
|
* Creates a connection between two NFA fragments on epsilon transition.
|
|
*
|
|
* [in-a] --a--> [out-a] --ε--> [in-b] --b--> [out-b]
|
|
*/
|
|
function altPair(first, second) {
|
|
first.out.accepting = false;
|
|
second.out.accepting = true;
|
|
|
|
first.out.addTransition(EPSILON, second.in);
|
|
|
|
return new NFA$1(first.in, second.out);
|
|
}
|
|
|
|
/**
|
|
* Alteration factory.
|
|
*
|
|
* Creates a alteration NFA for (at least) two NFA-fragments.
|
|
*/
|
|
function alt$1(first) {
|
|
for (var _len = arguments.length, fragments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
fragments[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
var _iteratorNormalCompletion = true;
|
|
var _didIteratorError = false;
|
|
var _iteratorError = undefined;
|
|
|
|
try {
|
|
for (var _iterator = fragments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
var fragment = _step.value;
|
|
|
|
first = altPair(first, fragment);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError = true;
|
|
_iteratorError = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
_iterator.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError) {
|
|
throw _iteratorError;
|
|
}
|
|
}
|
|
}
|
|
|
|
return first;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Disjunction NFA fragment: `a|b`
|
|
|
|
/**
|
|
* Creates a disjunction choice between two fragments.
|
|
*/
|
|
function orPair(first, second) {
|
|
var inState = new NFAState();
|
|
var outState = new NFAState();
|
|
|
|
inState.addTransition(EPSILON, first.in);
|
|
inState.addTransition(EPSILON, second.in);
|
|
|
|
outState.accepting = true;
|
|
first.out.accepting = false;
|
|
second.out.accepting = false;
|
|
|
|
first.out.addTransition(EPSILON, outState);
|
|
second.out.addTransition(EPSILON, outState);
|
|
|
|
return new NFA$1(inState, outState);
|
|
}
|
|
|
|
/**
|
|
* Disjunction factory.
|
|
*
|
|
* Creates a disjunction NFA for (at least) two NFA-fragments.
|
|
*/
|
|
function or$1(first) {
|
|
for (var _len2 = arguments.length, fragments = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
fragments[_key2 - 1] = arguments[_key2];
|
|
}
|
|
|
|
var _iteratorNormalCompletion2 = true;
|
|
var _didIteratorError2 = false;
|
|
var _iteratorError2 = undefined;
|
|
|
|
try {
|
|
for (var _iterator2 = fragments[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
|
var fragment = _step2.value;
|
|
|
|
first = orPair(first, fragment);
|
|
}
|
|
} catch (err) {
|
|
_didIteratorError2 = true;
|
|
_iteratorError2 = err;
|
|
} finally {
|
|
try {
|
|
if (!_iteratorNormalCompletion2 && _iterator2.return) {
|
|
_iterator2.return();
|
|
}
|
|
} finally {
|
|
if (_didIteratorError2) {
|
|
throw _iteratorError2;
|
|
}
|
|
}
|
|
}
|
|
|
|
return first;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// Kleene-closure
|
|
|
|
/**
|
|
* Kleene star/closure.
|
|
*
|
|
* a*
|
|
*/
|
|
function repExplicit(fragment) {
|
|
var inState = new NFAState();
|
|
var outState = new NFAState({
|
|
accepting: true
|
|
});
|
|
|
|
// 0 or more.
|
|
inState.addTransition(EPSILON, fragment.in);
|
|
inState.addTransition(EPSILON, outState);
|
|
|
|
fragment.out.accepting = false;
|
|
fragment.out.addTransition(EPSILON, outState);
|
|
outState.addTransition(EPSILON, fragment.in);
|
|
|
|
return new NFA$1(inState, outState);
|
|
}
|
|
|
|
/**
|
|
* Optimized Kleene-star: just adds ε-transitions from
|
|
* input to the output, and back.
|
|
*/
|
|
function rep$1(fragment) {
|
|
fragment.in.addTransition(EPSILON, fragment.out);
|
|
fragment.out.addTransition(EPSILON, fragment.in);
|
|
return fragment;
|
|
}
|
|
|
|
/**
|
|
* Optimized Plus: just adds ε-transitions from
|
|
* the output to the input.
|
|
*/
|
|
function plusRep$1(fragment) {
|
|
fragment.out.addTransition(EPSILON, fragment.in);
|
|
return fragment;
|
|
}
|
|
|
|
/**
|
|
* Optimized ? repetition: just adds ε-transitions from
|
|
* the input to the output.
|
|
*/
|
|
function questionRep$1(fragment) {
|
|
fragment.in.addTransition(EPSILON, fragment.out);
|
|
return fragment;
|
|
}
|
|
|
|
var builders$1 = {
|
|
alt: alt$1,
|
|
char: char$1,
|
|
e: e,
|
|
or: or$1,
|
|
rep: rep$1,
|
|
repExplicit: repExplicit,
|
|
plusRep: plusRep$1,
|
|
questionRep: questionRep$1
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
var parser$1 = parser$4;
|
|
|
|
var _require$1 = builders$1,
|
|
alt = _require$1.alt,
|
|
char = _require$1.char,
|
|
or = _require$1.or,
|
|
rep = _require$1.rep,
|
|
plusRep = _require$1.plusRep,
|
|
questionRep = _require$1.questionRep;
|
|
|
|
/**
|
|
* Helper `gen` function calls node type handler.
|
|
*/
|
|
|
|
|
|
function gen(node) {
|
|
if (node && !generator$1[node.type]) {
|
|
throw new Error(node.type + ' is not supported in NFA/DFA interpreter.');
|
|
}
|
|
|
|
return node ? generator$1[node.type](node) : '';
|
|
}
|
|
|
|
/**
|
|
* AST handler.
|
|
*/
|
|
var generator$1 = {
|
|
RegExp: function RegExp(node) {
|
|
if (node.flags !== '') {
|
|
throw new Error('NFA/DFA: Flags are not supported yet.');
|
|
}
|
|
|
|
return gen(node.body);
|
|
},
|
|
Alternative: function Alternative(node) {
|
|
var fragments = (node.expressions || []).map(gen);
|
|
return alt.apply(undefined, _toConsumableArray(fragments));
|
|
},
|
|
Disjunction: function Disjunction(node) {
|
|
return or(gen(node.left), gen(node.right));
|
|
},
|
|
Repetition: function Repetition(node) {
|
|
switch (node.quantifier.kind) {
|
|
case '*':
|
|
return rep(gen(node.expression));
|
|
case '+':
|
|
return plusRep(gen(node.expression));
|
|
case '?':
|
|
return questionRep(gen(node.expression));
|
|
default:
|
|
throw new Error('Unknown repeatition: ' + node.quantifier.kind + '.');
|
|
}
|
|
},
|
|
Char: function Char(node) {
|
|
if (node.kind !== 'simple') {
|
|
throw new Error('NFA/DFA: Only simple chars are supported yet.');
|
|
}
|
|
|
|
return char(node.value);
|
|
},
|
|
Group: function Group(node) {
|
|
return gen(node.expression);
|
|
}
|
|
};
|
|
|
|
var nfaFromRegexp = {
|
|
/**
|
|
* Builds an NFA from the passed regexp.
|
|
*/
|
|
build: function build(regexp) {
|
|
var ast = regexp;
|
|
|
|
if (regexp instanceof RegExp) {
|
|
regexp = '' + regexp;
|
|
}
|
|
|
|
if (typeof regexp === 'string') {
|
|
ast = parser$1.parse(regexp, {
|
|
captureLocations: true
|
|
});
|
|
}
|
|
|
|
return gen(ast);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var NFA = nfa;
|
|
var DFA = dfa;
|
|
|
|
var nfaFromRegExp = nfaFromRegexp;
|
|
var builders = builders$1;
|
|
|
|
var finiteAutomaton = {
|
|
|
|
/**
|
|
* Export NFA and DFA classes.
|
|
*/
|
|
NFA: NFA,
|
|
DFA: DFA,
|
|
|
|
/**
|
|
* Expose builders.
|
|
*/
|
|
builders: builders,
|
|
|
|
/**
|
|
* Builds an NFA for the passed regexp.
|
|
*
|
|
* @param string | AST | RegExp:
|
|
*
|
|
* a regular expression in different representations: a string,
|
|
* a RegExp object, or an AST.
|
|
*/
|
|
toNFA: function toNFA(regexp) {
|
|
return nfaFromRegExp.build(regexp);
|
|
},
|
|
|
|
|
|
/**
|
|
* Builds DFA for the passed regexp.
|
|
*
|
|
* @param string | AST | RegExp:
|
|
*
|
|
* a regular expression in different representations: a string,
|
|
* a RegExp object, or an AST.
|
|
*/
|
|
toDFA: function toDFA(regexp) {
|
|
return new DFA(this.toNFA(regexp));
|
|
},
|
|
|
|
|
|
/**
|
|
* Returns true if regexp accepts the string.
|
|
*/
|
|
test: function test(regexp, string) {
|
|
return this.toDFA(regexp).matches(string);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
/**
|
|
* The `RegExpTree` class provides runtime support for `compat-transpiler`
|
|
* module from `regexp-tree`.
|
|
*
|
|
* E.g. it tracks names of the capturing groups, in order to access the
|
|
* names on the matched result.
|
|
*
|
|
* It's a thin-wrapper on top of original regexp.
|
|
*/
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var RegExpTree$1 = function () {
|
|
/**
|
|
* Initializes a `RegExpTree` instance.
|
|
*
|
|
* @param RegExp - a regular expression
|
|
*
|
|
* @param Object state:
|
|
*
|
|
* An extra state which may store any related to transformation
|
|
* data, for example, names of the groups.
|
|
*
|
|
* - flags - original flags
|
|
* - groups - names of the groups, and their indices
|
|
* - source - original source
|
|
*/
|
|
function RegExpTree(re, _ref) {
|
|
var flags = _ref.flags,
|
|
groups = _ref.groups,
|
|
source = _ref.source;
|
|
|
|
_classCallCheck(this, RegExpTree);
|
|
|
|
this._re = re;
|
|
this._groups = groups;
|
|
|
|
// Original props.
|
|
this.flags = flags;
|
|
this.source = source || re.source;
|
|
this.dotAll = flags.includes('s');
|
|
|
|
// Inherited directly from `re`.
|
|
this.global = re.global;
|
|
this.ignoreCase = re.ignoreCase;
|
|
this.multiline = re.multiline;
|
|
this.sticky = re.sticky;
|
|
this.unicode = re.unicode;
|
|
}
|
|
|
|
/**
|
|
* Facade wrapper for RegExp `test` method.
|
|
*/
|
|
|
|
|
|
_createClass(RegExpTree, [{
|
|
key: 'test',
|
|
value: function test(string) {
|
|
return this._re.test(string);
|
|
}
|
|
|
|
/**
|
|
* Facade wrapper for RegExp `compile` method.
|
|
*/
|
|
|
|
}, {
|
|
key: 'compile',
|
|
value: function compile(string) {
|
|
return this._re.compile(string);
|
|
}
|
|
|
|
/**
|
|
* Facade wrapper for RegExp `toString` method.
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString() {
|
|
if (!this._toStringResult) {
|
|
this._toStringResult = '/' + this.source + '/' + this.flags;
|
|
}
|
|
return this._toStringResult;
|
|
}
|
|
|
|
/**
|
|
* Facade wrapper for RegExp `exec` method.
|
|
*/
|
|
|
|
}, {
|
|
key: 'exec',
|
|
value: function exec(string) {
|
|
var result = this._re.exec(string);
|
|
|
|
if (!this._groups || !result) {
|
|
return result;
|
|
}
|
|
|
|
result.groups = {};
|
|
|
|
for (var group in this._groups) {
|
|
var groupNumber = this._groups[group];
|
|
result.groups[group] = result[groupNumber];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}]);
|
|
|
|
return RegExpTree;
|
|
}();
|
|
|
|
var runtime = {
|
|
RegExpTree: RegExpTree$1
|
|
};
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var compatTranspiler = compatTranspiler$1;
|
|
var generator = generator_1;
|
|
var optimizer = optimizer$1;
|
|
var parser = parser$4;
|
|
var _transform = transform$1;
|
|
var _traverse = traverse$1;
|
|
var fa = finiteAutomaton;
|
|
|
|
var _require = runtime,
|
|
RegExpTree = _require.RegExpTree;
|
|
|
|
/**
|
|
* An API object for RegExp processing (parsing/transform/generation).
|
|
*/
|
|
|
|
|
|
var regexpTree$3 = {
|
|
/**
|
|
* Parser module exposed.
|
|
*/
|
|
parser: parser,
|
|
|
|
/**
|
|
* Expose finite-automaton module.
|
|
*/
|
|
fa: fa,
|
|
|
|
/**
|
|
* `TransformResult` exposed.
|
|
*/
|
|
TransformResult: _transform.TransformResult,
|
|
|
|
/**
|
|
* Parses a regexp string, producing an AST.
|
|
*
|
|
* @param string regexp
|
|
*
|
|
* a regular expression in different formats: string, AST, RegExp.
|
|
*
|
|
* @param Object options
|
|
*
|
|
* parsing options for this parse call. Default are:
|
|
*
|
|
* - captureLocations: boolean
|
|
* - any other custom options
|
|
*
|
|
* @return Object AST
|
|
*/
|
|
parse: function parse(regexp, options) {
|
|
return parser.parse('' + regexp, options);
|
|
},
|
|
|
|
|
|
/**
|
|
* Traverses a RegExp AST.
|
|
*
|
|
* @param Object ast
|
|
* @param Object | Array<Object> handlers
|
|
*
|
|
* Each `handler` is an object containing handler function for needed
|
|
* node types. Example:
|
|
*
|
|
* regexpTree.traverse(ast, {
|
|
* onChar(node) {
|
|
* ...
|
|
* },
|
|
* });
|
|
*
|
|
* The value for a node type may also be an object with functions pre and post.
|
|
* This enables more context-aware analyses, e.g. measuring star height.
|
|
*/
|
|
traverse: function traverse(ast, handlers, options) {
|
|
return _traverse.traverse(ast, handlers, options);
|
|
},
|
|
|
|
|
|
/**
|
|
* Transforms a regular expression.
|
|
*
|
|
* A regexp can be passed in different formats (string, regexp or AST),
|
|
* applying a set of transformations. It is a convenient wrapper
|
|
* on top of "parse-traverse-generate" tool chain.
|
|
*
|
|
* @param string | AST | RegExp regexp - a regular expression;
|
|
* @param Object | Array<Object> handlers - a list of handlers.
|
|
*
|
|
* @return TransformResult - a transformation result.
|
|
*/
|
|
transform: function transform(regexp, handlers) {
|
|
return _transform.transform(regexp, handlers);
|
|
},
|
|
|
|
|
|
/**
|
|
* Generates a RegExp string from an AST.
|
|
*
|
|
* @param Object ast
|
|
*
|
|
* Invariant:
|
|
*
|
|
* regexpTree.generate(regexpTree.parse('/[a-z]+/i')); // '/[a-z]+/i'
|
|
*/
|
|
generate: function generate(ast) {
|
|
return generator.generate(ast);
|
|
},
|
|
|
|
|
|
/**
|
|
* Creates a RegExp object from a regexp string.
|
|
*
|
|
* @param string regexp
|
|
*/
|
|
toRegExp: function toRegExp(regexp) {
|
|
var compat = this.compatTranspile(regexp);
|
|
return new RegExp(compat.getSource(), compat.getFlags());
|
|
},
|
|
|
|
|
|
/**
|
|
* Optimizes a regular expression by replacing some
|
|
* sub-expressions with their idiomatic patterns.
|
|
*
|
|
* @param string regexp
|
|
*
|
|
* @return TransformResult object
|
|
*/
|
|
optimize: function optimize(regexp, whitelist) {
|
|
var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
|
|
blacklist = _ref.blacklist;
|
|
|
|
return optimizer.optimize(regexp, { whitelist: whitelist, blacklist: blacklist });
|
|
},
|
|
|
|
|
|
/**
|
|
* Translates a regular expression in new syntax or in new format
|
|
* into equivalent expressions in old syntax.
|
|
*
|
|
* @param string regexp
|
|
*
|
|
* @return TransformResult object
|
|
*/
|
|
compatTranspile: function compatTranspile(regexp, whitelist) {
|
|
return compatTranspiler.transform(regexp, whitelist);
|
|
},
|
|
|
|
|
|
/**
|
|
* Executes a regular expression on a string.
|
|
*
|
|
* @param RegExp|string re - a regular expression.
|
|
* @param string string - a testing string.
|
|
*/
|
|
exec: function exec(re, string) {
|
|
if (typeof re === 'string') {
|
|
var compat = this.compatTranspile(re);
|
|
var extra = compat.getExtra();
|
|
|
|
if (extra.namedCapturingGroups) {
|
|
re = new RegExpTree(compat.toRegExp(), {
|
|
flags: compat.getFlags(),
|
|
source: compat.getSource(),
|
|
groups: extra.namedCapturingGroups
|
|
});
|
|
} else {
|
|
re = compat.toRegExp();
|
|
}
|
|
}
|
|
|
|
return re.exec(string);
|
|
}
|
|
};
|
|
|
|
var regexpTree_1 = regexpTree$3;
|
|
|
|
/**
|
|
* The MIT License (MIT)
|
|
* Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
|
|
*/
|
|
|
|
var regexpTree$2 = regexpTree_1;
|
|
|
|
// Exports an Analyzer subclass
|
|
|
|
const regexpTree$1 = regexpTree$2;
|
|
const analyzer$1 = analyzer$2;
|
|
|
|
class HeuristicAnalyzer extends analyzer$1.Analyzer {
|
|
constructor(analyzerOptions) {
|
|
super(analyzerOptions);
|
|
}
|
|
|
|
isVulnerable(regExp) {
|
|
// Heuristic #1: Star height > 1
|
|
const starHeight = this._measureStarHeight(regExp);
|
|
if (starHeight > 1) {
|
|
return true;
|
|
}
|
|
|
|
// Heuristic #2: # repetitions > limit
|
|
// TODO This is a poor heuristic
|
|
const nRepetitions = this._measureRepetitions(regExp);
|
|
if (nRepetitions > this.options.heuristic_replimit) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
genAttackString(regExp) {
|
|
return null;
|
|
}
|
|
|
|
_measureStarHeight(regExp) {
|
|
let currentStarHeight = 0;
|
|
let maxObservedStarHeight = 0;
|
|
|
|
const ast = regexpTree$1.parse(regExp);
|
|
|
|
regexpTree$1.traverse(ast, {
|
|
Repetition: {
|
|
pre({ node }) {
|
|
currentStarHeight++;
|
|
if (maxObservedStarHeight < currentStarHeight) {
|
|
maxObservedStarHeight = currentStarHeight;
|
|
}
|
|
},
|
|
|
|
post({ node }) {
|
|
currentStarHeight--;
|
|
}
|
|
}
|
|
});
|
|
|
|
return maxObservedStarHeight;
|
|
}
|
|
|
|
_measureRepetitions(regExp) {
|
|
let nRepetitions = 0;
|
|
|
|
const ast = regexpTree$1.parse(regExp);
|
|
regexpTree$1.traverse(ast, {
|
|
Repetition: {
|
|
pre({ node }) {
|
|
nRepetitions++;
|
|
}
|
|
}
|
|
});
|
|
|
|
return nRepetitions;
|
|
}
|
|
}
|
|
|
|
var heuristicAnalyzer$1 = HeuristicAnalyzer;
|
|
|
|
// Load the analyzers
|
|
const heuristicAnalyzer = heuristicAnalyzer$1;
|
|
|
|
var analyzerFamily$1 = [heuristicAnalyzer];
|
|
|
|
const analyzer = analyzer$2;
|
|
const analyzerFamily = analyzerFamily$1;
|
|
|
|
const DEFAULT_SAFE_REP_LIMIT = 25;
|
|
const RET_IS_SAFE = true;
|
|
const RET_IS_VULNERABLE = false;
|
|
|
|
class Args {
|
|
constructor(regExp, analyzerOptions) {
|
|
this.regExp = regExp;
|
|
this.analyzerOptions = analyzerOptions;
|
|
}
|
|
}
|
|
|
|
function safeRegex(re, opts) {
|
|
try {
|
|
const args = buildArgs(re, opts);
|
|
const analyzerResponses = askAnalyzersIfVulnerable(args);
|
|
|
|
// Did any analyzer say true?
|
|
if (analyzerResponses.find((isVulnerable) => isVulnerable)) {
|
|
return RET_IS_VULNERABLE;
|
|
} else {
|
|
return RET_IS_SAFE;
|
|
}
|
|
} catch (err) {
|
|
// Invalid or unparseable input
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function buildArgs(re, opts) {
|
|
// Build AnalyzerOptions
|
|
if (!opts) opts = {};
|
|
const heuristic_replimit = opts.limit === undefined ? DEFAULT_SAFE_REP_LIMIT : opts.limit;
|
|
|
|
const analyzerOptions = new analyzer.AnalyzerOptions(heuristic_replimit);
|
|
|
|
// Build RegExp
|
|
let regExp = null;
|
|
// Construct a RegExp object
|
|
if (re instanceof RegExp) {
|
|
regExp = re;
|
|
} else if (typeof re === 'string') {
|
|
regExp = new RegExp(re);
|
|
} else {
|
|
regExp = new RegExp(String(re));
|
|
}
|
|
|
|
return new Args(regExp, analyzerOptions);
|
|
}
|
|
|
|
function askAnalyzersIfVulnerable(args) {
|
|
let analyzerSaysVulnerable = [];
|
|
|
|
// Query the Analyzers
|
|
let Analyzer;
|
|
for (Analyzer of analyzerFamily) {
|
|
try {
|
|
const analyzer = new Analyzer(args.analyzerOptions);
|
|
analyzerSaysVulnerable.push(analyzer.isVulnerable(args.regExp));
|
|
} catch (err) {
|
|
/* istanbul ignore next */ // No need to worry about code coverage here.
|
|
analyzerSaysVulnerable.push(false);
|
|
}
|
|
}
|
|
|
|
return analyzerSaysVulnerable;
|
|
}
|
|
|
|
// Export
|
|
|
|
var safeRegex_1 = safeRegex;
|
|
|
|
var safeRegex$1 = /*@__PURE__*/getDefaultExportFromCjs(safeRegex_1);
|
|
|
|
class SettingTab extends obsidian.PluginSettingTab {
|
|
constructor(app, plugin) {
|
|
super(app, plugin);
|
|
this.plugin = plugin;
|
|
}
|
|
displSw(cont) {
|
|
cont.findAll(".setting-item").forEach((el) => {
|
|
if (el.getAttr("class").includes("media_folder_set")) {
|
|
if (this.plugin.settings.saveAttE === "obsFolder" ||
|
|
this.plugin.settings.saveAttE === "nextToNote") {
|
|
el.hide();
|
|
}
|
|
else {
|
|
el.show();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
display() {
|
|
let { containerEl } = this;
|
|
containerEl.empty();
|
|
containerEl.createEl("h1", { text: APP_TITLE });
|
|
containerEl.createEl("div");
|
|
// donheader.createEl("a", { text: "Support the project! ", href: "https://www.buymeacoffee.com/sergeikorneev", cls: "donheader_txt" })
|
|
containerEl.createEl("h3", { text: "Interface settings" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Show notifications")
|
|
.setDesc("Show notifications when pages were processed.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.showNotifications)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.showNotifications = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Disable additional commands")
|
|
.setDesc("Do not show additional commands in command palette. Reload the plugin in settings to take effect (turn off/on).")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.disAddCom)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.disAddCom = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
containerEl.createEl("h3", { text: "Processing settings" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Automatic processing")
|
|
.setDesc("Process notes on create/copy/paste.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.realTimeUpdate)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.realTimeUpdate = value;
|
|
yield this.plugin.saveSettings();
|
|
this.plugin.setupQueueInterval();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Automatic processing interval")
|
|
.setDesc("Interval in seconds for processing update. It takes some time to reveal changed content of a note to plugins.")
|
|
.addText((text) => text
|
|
.setValue(String(this.plugin.settings.realTimeUpdateInterval))
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
let numberValue = Number(value);
|
|
if (isNaN(numberValue) ||
|
|
!Number.isInteger(numberValue) ||
|
|
numberValue <= 5 ||
|
|
numberValue > 3600) {
|
|
displayError("The value should be a positive integer number between 5 and 3600!");
|
|
return;
|
|
}
|
|
if (numberValue < 5) {
|
|
numberValue = 5;
|
|
}
|
|
this.plugin.settings.realTimeUpdateInterval = numberValue;
|
|
yield this.plugin.saveSettings();
|
|
this.plugin.setupQueueInterval();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Number of retries for every single attachment")
|
|
.setDesc("If an error occurs during downloading (network etc.) try to re-download several times.")
|
|
.addText((text) => text
|
|
.setValue(String(this.plugin.settings.tryCount))
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
let numberValue = Number(value);
|
|
if (isNaN(numberValue) ||
|
|
!Number.isInteger(numberValue) ||
|
|
numberValue < 1 ||
|
|
numberValue > 6) {
|
|
displayError("The value should be a positive integer number between 1 and 6!");
|
|
return;
|
|
}
|
|
this.plugin.settings.tryCount = numberValue;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Process all new markdown files")
|
|
.setDesc("Process all new created/cloud-synced files with corresponding extensions.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.processCreated)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.processCreated = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Process all new attachments")
|
|
.setDesc("The plugin will also move all attachments from obsidian default folder to plugin folder.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.processAll)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.processAll = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Use MD5 for new attachments (Pasted images and files)")
|
|
.setDesc("The plugin will use MD5 when renaming all new attachments.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.useMD5ForNewAtt)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.useMD5ForNewAtt = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Download unknown filetypes")
|
|
.setDesc("Download unknown filetypes and save them with .unknown extension.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.downUnknown)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.downUnknown = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Compress images (Web Images)")
|
|
.setDesc("Compress all downloaded images. May reduce file size by several times, but can also affect performance.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.PngToJpeg)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.PngToJpeg = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Compress images (Pasted Images)")
|
|
.setDesc("Compress all pasted images. May reduce file size by several times, but can also affect performance.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.PngToJpegLocal)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.PngToJpegLocal = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Compression type")
|
|
.setDesc("Select image compression type. Keep in mind that webp format has image size limitations.")
|
|
.addDropdown(dropdown => {
|
|
dropdown
|
|
.addOption("image/webp", "WebP")
|
|
.addOption("image/jpeg", "JPEG")
|
|
.setValue(this.plugin.settings.ImgCompressionType)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.ImgCompressionType = value;
|
|
yield this.plugin.saveSettings();
|
|
}));
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Excluded folders")
|
|
.setDesc("Excluded folders. New files in these folders will not be processed automatically.")
|
|
.addTextArea(text => {
|
|
text
|
|
.setPlaceholder("Enter the full path in new lines, e.g. RootFolder/Subfolder.")
|
|
.setValue(this.plugin.settings.ExcludedFoldersList)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
let FoldersArray = value.split(/\r?\n|\r|\n/g);
|
|
if (FoldersArray.length >= 1) {
|
|
let regexconverted = trimAny(FoldersArray.map((path) => { if (trimAny(path, [" ", "|", "/", "\\"]) !== "") {
|
|
return "(^" + trimAny(path, [" ", "|", "/", "\\"]) + "$)";
|
|
} }).join("|").replace('\\', '/'), [" ", "|", "/", "\\"]);
|
|
this.plugin.settings.ExcludedFoldersList = value;
|
|
this.plugin.settings.ExcludedFoldersListRegexp = regexconverted;
|
|
yield this.plugin.saveSettings();
|
|
console.log("Excluded folders regex:", regexconverted);
|
|
}
|
|
}));
|
|
text.inputEl.rows = 4;
|
|
text.inputEl.style.width = "100%";
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Image Quality")
|
|
.setDesc("Image quality selection (30 to 100).")
|
|
.addText((text) => text
|
|
.setValue(String(this.plugin.settings.JpegQuality))
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
let numberValue = Number(value);
|
|
if (isNaN(numberValue) ||
|
|
!Number.isInteger(numberValue) ||
|
|
numberValue < 10 ||
|
|
numberValue > 100) {
|
|
displayError("The value should be a positive integer number between 10 and 100!");
|
|
return;
|
|
}
|
|
this.plugin.settings.JpegQuality = numberValue;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("File size lower limit in Kb")
|
|
.setDesc("Do not download files with size less than this value. Set 0 for no limit.")
|
|
.addText((text) => text
|
|
.setValue(String(this.plugin.settings.filesizeLimit))
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
let numberValue = Number(value);
|
|
if (isNaN(numberValue) ||
|
|
!Number.isInteger(numberValue) ||
|
|
numberValue < 0) {
|
|
displayError("The value should be a positive integer!");
|
|
return;
|
|
}
|
|
if (numberValue < 0) {
|
|
numberValue = 0;
|
|
}
|
|
this.plugin.settings.filesizeLimit = numberValue;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Exclusions")
|
|
.setDesc("The plugin will not download attachments with these extensions.")
|
|
.addText((text) => text
|
|
.setValue(this.plugin.settings.ignoredExt)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.ignoredExt = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Do not create Obsidian attachment folder (For compatibility with other plugins)")
|
|
.setDesc("The plugin will not create an Obsidian attachments folder. This may cause the plugin to behave incorrectly. ")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.DoNotCreateObsFolder)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.DoNotCreateObsFolder = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
containerEl.createEl("h3", { text: "Note settings" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Preserve link captions")
|
|
.setDesc("Add media links captions to converted tags.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.useCaptions)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.useCaptions = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Add original filename or 'Open file' tag")
|
|
.setDesc("Add [[original filename]] or [original filename](link to attachment) after replaced tag (only for file:// protocol or dropped/pasted files ).")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.addNameOfFile)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.addNameOfFile = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Include pattern")
|
|
.setDesc("Include only files with extensions only matching this pattern. Example: md|canvas")
|
|
.addText((text) => text.setValue(this.plugin.settings.includeps).onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
//Transform string to regex
|
|
let ExtArray = value.split("|");
|
|
if (ExtArray.length >= 1) {
|
|
let regexconverted = trimAny(ExtArray.map((extension) => { if (trimAny(extension, [" ", "|"]) !== "") {
|
|
return "(?<" + trimAny(extension, [" ", "|"]) + ">.*\\." + trimAny(extension, [" ", "|"]) + ")";
|
|
} }).join("|"), [" ", "|"]);
|
|
if (!safeRegex$1(value)) {
|
|
displayError("Unsafe regex! https://www.npmjs.com/package/safe-regex");
|
|
return;
|
|
}
|
|
this.plugin.settings.includepattern = regexconverted;
|
|
logError(regexconverted);
|
|
yield this.plugin.saveSettings();
|
|
}
|
|
})));
|
|
containerEl.createEl("h3", { text: "Orphaned attachments" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Remove files completely")
|
|
.setDesc("Do not move orphaned files into the garbage can.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.removeOrphansCompl)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.removeOrphansCompl = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
containerEl.createEl("h3", { text: "Media folder settings" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("How to write paths in tags")
|
|
.setDesc("Select whether to write full paths in tags or not.")
|
|
.addDropdown((text) => text
|
|
.addOption("fullDirPath", "Full path")
|
|
.addOption("onlyRelative", "Relative to note")
|
|
.addOption("baseFileName", "Only filename")
|
|
.setValue(this.plugin.settings.pathInTags)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.pathInTags = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Date format")
|
|
.setDesc("Date format for ${date} variable. E.g. \
|
|
| MMMM Do YYYY, h:mm:ss a (March 20th 2024, 10:54:46 am) \
|
|
| dddd (Wednesday)\
|
|
| MMM Do YY (Mar 20th 24)")
|
|
.addText((text) => text.setValue(this.plugin.settings.DateFormat).onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
if (value.match(/(\)|\(|\"|\'|\#|\]|\[|\:|\>|\<|\*|\|)/g) !== null) {
|
|
displayError("Unsafe folder name! Some chars are forbidden in some filesystems.");
|
|
return;
|
|
}
|
|
this.plugin.settings.DateFormat = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Folder to save new attachments")
|
|
.setDesc("Select where all new attachments will be saved.\nYou can use templates e.g. _resouces/${date}/${notename}")
|
|
.addDropdown((text) => text
|
|
.addOption("obsFolder", "Copy Obsidian settings")
|
|
.addOption("inFolderBelow", "In the root folder specified below")
|
|
.addOption("nextToNoteS", "Next to note in the folder specified below")
|
|
.setValue(this.plugin.settings.saveAttE)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.saveAttE = value;
|
|
this.displSw(containerEl);
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Move/delete/rename media folder")
|
|
.setDesc("Rename or move this folder to the obsidian or system garbage can when the associated note is deleted/renamed/moved. \
|
|
This setting takes effect only if the path contains ${notename} template at the end\
|
|
and the options 'Next to note in the folder specified below' / 'Relative to note' are selected.\
|
|
Use this setting at your own risk.")
|
|
.setClass("media_folder_set")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(this.plugin.settings.removeMediaFolder)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
this.plugin.settings.removeMediaFolder = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Media folder")
|
|
.setDesc("Folder to keep all downloaded media files.")
|
|
.setClass("media_folder_set")
|
|
.addText((text) => text
|
|
.setValue(this.plugin.settings.mediaRootDir)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
if (value.match(/(\)|\(|\"|\'|\#|\]|\[|\:|\>|\<|\*|\|)/g) !== null) {
|
|
displayError("Unsafe folder name! Some chars are forbidden in some filesystems.");
|
|
return;
|
|
}
|
|
this.plugin.settings.mediaRootDir = value;
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
containerEl.createEl("h3", { text: "Troubleshooting" });
|
|
new obsidian.Setting(containerEl)
|
|
.setName("Debug")
|
|
.setDesc("Enable debug output to console.")
|
|
.addToggle((toggle) => toggle
|
|
.setValue(VERBOSE)
|
|
.onChange((value) => __awaiter(this, void 0, void 0, function* () {
|
|
setDebug(value);
|
|
yield this.plugin.saveSettings();
|
|
})));
|
|
this.displSw(containerEl);
|
|
}
|
|
}
|
|
|
|
var AsyncLock$1 = function (opts) {
|
|
opts = opts || {};
|
|
|
|
this.Promise = opts.Promise || Promise;
|
|
|
|
// format: {key : [fn, fn]}
|
|
// queues[key] = null indicates no job running for key
|
|
this.queues = Object.create(null);
|
|
|
|
// lock is reentrant for same domain
|
|
this.domainReentrant = opts.domainReentrant || false;
|
|
if (this.domainReentrant) {
|
|
if (typeof process === 'undefined' || typeof process.domain === 'undefined') {
|
|
throw new Error(
|
|
'Domain-reentrant locks require `process.domain` to exist. Please flip `opts.domainReentrant = false`, ' +
|
|
'use a NodeJS version that still implements Domain, or install a browser polyfill.');
|
|
}
|
|
// domain of current running func {key : fn}
|
|
this.domains = Object.create(null);
|
|
}
|
|
|
|
this.timeout = opts.timeout || AsyncLock$1.DEFAULT_TIMEOUT;
|
|
this.maxOccupationTime = opts.maxOccupationTime || AsyncLock$1.DEFAULT_MAX_OCCUPATION_TIME;
|
|
this.maxExecutionTime = opts.maxExecutionTime || AsyncLock$1.DEFAULT_MAX_EXECUTION_TIME;
|
|
if (opts.maxPending === Infinity || (Number.isInteger(opts.maxPending) && opts.maxPending >= 0)) {
|
|
this.maxPending = opts.maxPending;
|
|
} else {
|
|
this.maxPending = AsyncLock$1.DEFAULT_MAX_PENDING;
|
|
}
|
|
};
|
|
|
|
AsyncLock$1.DEFAULT_TIMEOUT = 0; //Never
|
|
AsyncLock$1.DEFAULT_MAX_OCCUPATION_TIME = 0; //Never
|
|
AsyncLock$1.DEFAULT_MAX_EXECUTION_TIME = 0; //Never
|
|
AsyncLock$1.DEFAULT_MAX_PENDING = 1000;
|
|
|
|
/**
|
|
* Acquire Locks
|
|
*
|
|
* @param {String|Array} key resource key or keys to lock
|
|
* @param {function} fn async function
|
|
* @param {function} cb callback function, otherwise will return a promise
|
|
* @param {Object} opts options
|
|
*/
|
|
AsyncLock$1.prototype.acquire = function (key, fn, cb, opts) {
|
|
if (Array.isArray(key)) {
|
|
return this._acquireBatch(key, fn, cb, opts);
|
|
}
|
|
|
|
if (typeof (fn) !== 'function') {
|
|
throw new Error('You must pass a function to execute');
|
|
}
|
|
|
|
// faux-deferred promise using new Promise() (as Promise.defer is deprecated)
|
|
var deferredResolve = null;
|
|
var deferredReject = null;
|
|
var deferred = null;
|
|
|
|
if (typeof (cb) !== 'function') {
|
|
opts = cb;
|
|
cb = null;
|
|
|
|
// will return a promise
|
|
deferred = new this.Promise(function(resolve, reject) {
|
|
deferredResolve = resolve;
|
|
deferredReject = reject;
|
|
});
|
|
}
|
|
|
|
opts = opts || {};
|
|
|
|
var resolved = false;
|
|
var timer = null;
|
|
var occupationTimer = null;
|
|
var executionTimer = null;
|
|
var self = this;
|
|
|
|
var done = function (locked, err, ret) {
|
|
|
|
if (occupationTimer) {
|
|
clearTimeout(occupationTimer);
|
|
occupationTimer = null;
|
|
}
|
|
|
|
if (executionTimer) {
|
|
clearTimeout(executionTimer);
|
|
executionTimer = null;
|
|
}
|
|
|
|
if (locked) {
|
|
if (!!self.queues[key] && self.queues[key].length === 0) {
|
|
delete self.queues[key];
|
|
}
|
|
if (self.domainReentrant) {
|
|
delete self.domains[key];
|
|
}
|
|
}
|
|
|
|
if (!resolved) {
|
|
if (!deferred) {
|
|
if (typeof (cb) === 'function') {
|
|
cb(err, ret);
|
|
}
|
|
}
|
|
else {
|
|
//promise mode
|
|
if (err) {
|
|
deferredReject(err);
|
|
}
|
|
else {
|
|
deferredResolve(ret);
|
|
}
|
|
}
|
|
resolved = true;
|
|
}
|
|
|
|
if (locked) {
|
|
//run next func
|
|
if (!!self.queues[key] && self.queues[key].length > 0) {
|
|
self.queues[key].shift()();
|
|
}
|
|
}
|
|
};
|
|
|
|
var exec = function (locked) {
|
|
if (resolved) { // may due to timed out
|
|
return done(locked);
|
|
}
|
|
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = null;
|
|
}
|
|
|
|
if (self.domainReentrant && locked) {
|
|
self.domains[key] = process.domain;
|
|
}
|
|
|
|
var maxExecutionTime = opts.maxExecutionTime || self.maxExecutionTime;
|
|
if (maxExecutionTime) {
|
|
executionTimer = setTimeout(function () {
|
|
if (!!self.queues[key]) {
|
|
done(locked, new Error('Maximum execution time is exceeded ' + key));
|
|
}
|
|
}, maxExecutionTime);
|
|
}
|
|
|
|
// Callback mode
|
|
if (fn.length === 1) {
|
|
var called = false;
|
|
try {
|
|
fn(function (err, ret) {
|
|
if (!called) {
|
|
called = true;
|
|
done(locked, err, ret);
|
|
}
|
|
});
|
|
} catch (err) {
|
|
// catching error thrown in user function fn
|
|
if (!called) {
|
|
called = true;
|
|
done(locked, err);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// Promise mode
|
|
self._promiseTry(function () {
|
|
return fn();
|
|
})
|
|
.then(function(ret){
|
|
done(locked, undefined, ret);
|
|
}, function(error){
|
|
done(locked, error);
|
|
});
|
|
}
|
|
};
|
|
|
|
if (self.domainReentrant && !!process.domain) {
|
|
exec = process.domain.bind(exec);
|
|
}
|
|
|
|
var maxPending = opts.maxPending || self.maxPending;
|
|
|
|
if (!self.queues[key]) {
|
|
self.queues[key] = [];
|
|
exec(true);
|
|
}
|
|
else if (self.domainReentrant && !!process.domain && process.domain === self.domains[key]) {
|
|
// If code is in the same domain of current running task, run it directly
|
|
// Since lock is re-enterable
|
|
exec(false);
|
|
}
|
|
else if (self.queues[key].length >= maxPending) {
|
|
done(false, new Error('Too many pending tasks in queue ' + key));
|
|
}
|
|
else {
|
|
var taskFn = function () {
|
|
exec(true);
|
|
};
|
|
if (opts.skipQueue) {
|
|
self.queues[key].unshift(taskFn);
|
|
} else {
|
|
self.queues[key].push(taskFn);
|
|
}
|
|
|
|
var timeout = opts.timeout || self.timeout;
|
|
if (timeout) {
|
|
timer = setTimeout(function () {
|
|
timer = null;
|
|
done(false, new Error('async-lock timed out in queue ' + key));
|
|
}, timeout);
|
|
}
|
|
}
|
|
|
|
var maxOccupationTime = opts.maxOccupationTime || self.maxOccupationTime;
|
|
if (maxOccupationTime) {
|
|
occupationTimer = setTimeout(function () {
|
|
if (!!self.queues[key]) {
|
|
done(false, new Error('Maximum occupation time is exceeded in queue ' + key));
|
|
}
|
|
}, maxOccupationTime);
|
|
}
|
|
|
|
if (deferred) {
|
|
return deferred;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Below is how this function works:
|
|
*
|
|
* Equivalent code:
|
|
* self.acquire(key1, function(cb){
|
|
* self.acquire(key2, function(cb){
|
|
* self.acquire(key3, fn, cb);
|
|
* }, cb);
|
|
* }, cb);
|
|
*
|
|
* Equivalent code:
|
|
* var fn3 = getFn(key3, fn);
|
|
* var fn2 = getFn(key2, fn3);
|
|
* var fn1 = getFn(key1, fn2);
|
|
* fn1(cb);
|
|
*/
|
|
AsyncLock$1.prototype._acquireBatch = function (keys, fn, cb, opts) {
|
|
if (typeof (cb) !== 'function') {
|
|
opts = cb;
|
|
cb = null;
|
|
}
|
|
|
|
var self = this;
|
|
var getFn = function (key, fn) {
|
|
return function (cb) {
|
|
self.acquire(key, fn, cb, opts);
|
|
};
|
|
};
|
|
|
|
var fnx = keys.reduceRight(function (prev, key) {
|
|
return getFn(key, prev);
|
|
}, fn);
|
|
|
|
if (typeof (cb) === 'function') {
|
|
fnx(cb);
|
|
}
|
|
else {
|
|
return new this.Promise(function (resolve, reject) {
|
|
// check for promise mode in case keys is empty array
|
|
if (fnx.length === 1) {
|
|
fnx(function (err, ret) {
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
else {
|
|
resolve(ret);
|
|
}
|
|
});
|
|
} else {
|
|
resolve(fnx());
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Whether there is any running or pending asyncFunc
|
|
*
|
|
* @param {String} key
|
|
*/
|
|
AsyncLock$1.prototype.isBusy = function (key) {
|
|
if (!key) {
|
|
return Object.keys(this.queues).length > 0;
|
|
}
|
|
else {
|
|
return !!this.queues[key];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Promise.try() implementation to become independent of Q-specific methods
|
|
*/
|
|
AsyncLock$1.prototype._promiseTry = function(fn) {
|
|
try {
|
|
return this.Promise.resolve(fn());
|
|
} catch (e) {
|
|
return this.Promise.reject(e);
|
|
}
|
|
};
|
|
|
|
var lib = AsyncLock$1;
|
|
|
|
var asyncLock = lib;
|
|
|
|
var AsyncLock = /*@__PURE__*/getDefaultExportFromCjs(asyncLock);
|
|
|
|
var moment$1 = {exports: {}};
|
|
|
|
moment$1.exports;
|
|
|
|
(function (module, exports) {
|
|
(function (global, factory) {
|
|
module.exports = factory() ;
|
|
}(commonjsGlobal, (function () {
|
|
var hookCallback;
|
|
|
|
function hooks() {
|
|
return hookCallback.apply(null, arguments);
|
|
}
|
|
|
|
// This is done to register the method called with moment()
|
|
// without creating circular dependencies.
|
|
function setHookCallback(callback) {
|
|
hookCallback = callback;
|
|
}
|
|
|
|
function isArray(input) {
|
|
return (
|
|
input instanceof Array ||
|
|
Object.prototype.toString.call(input) === '[object Array]'
|
|
);
|
|
}
|
|
|
|
function isObject(input) {
|
|
// IE8 will treat undefined and null as object if it wasn't for
|
|
// input != null
|
|
return (
|
|
input != null &&
|
|
Object.prototype.toString.call(input) === '[object Object]'
|
|
);
|
|
}
|
|
|
|
function hasOwnProp(a, b) {
|
|
return Object.prototype.hasOwnProperty.call(a, b);
|
|
}
|
|
|
|
function isObjectEmpty(obj) {
|
|
if (Object.getOwnPropertyNames) {
|
|
return Object.getOwnPropertyNames(obj).length === 0;
|
|
} else {
|
|
var k;
|
|
for (k in obj) {
|
|
if (hasOwnProp(obj, k)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function isUndefined(input) {
|
|
return input === void 0;
|
|
}
|
|
|
|
function isNumber(input) {
|
|
return (
|
|
typeof input === 'number' ||
|
|
Object.prototype.toString.call(input) === '[object Number]'
|
|
);
|
|
}
|
|
|
|
function isDate(input) {
|
|
return (
|
|
input instanceof Date ||
|
|
Object.prototype.toString.call(input) === '[object Date]'
|
|
);
|
|
}
|
|
|
|
function map(arr, fn) {
|
|
var res = [],
|
|
i,
|
|
arrLen = arr.length;
|
|
for (i = 0; i < arrLen; ++i) {
|
|
res.push(fn(arr[i], i));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function extend(a, b) {
|
|
for (var i in b) {
|
|
if (hasOwnProp(b, i)) {
|
|
a[i] = b[i];
|
|
}
|
|
}
|
|
|
|
if (hasOwnProp(b, 'toString')) {
|
|
a.toString = b.toString;
|
|
}
|
|
|
|
if (hasOwnProp(b, 'valueOf')) {
|
|
a.valueOf = b.valueOf;
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
function createUTC(input, format, locale, strict) {
|
|
return createLocalOrUTC(input, format, locale, strict, true).utc();
|
|
}
|
|
|
|
function defaultParsingFlags() {
|
|
// We need to deep clone this object.
|
|
return {
|
|
empty: false,
|
|
unusedTokens: [],
|
|
unusedInput: [],
|
|
overflow: -2,
|
|
charsLeftOver: 0,
|
|
nullInput: false,
|
|
invalidEra: null,
|
|
invalidMonth: null,
|
|
invalidFormat: false,
|
|
userInvalidated: false,
|
|
iso: false,
|
|
parsedDateParts: [],
|
|
era: null,
|
|
meridiem: null,
|
|
rfc2822: false,
|
|
weekdayMismatch: false,
|
|
};
|
|
}
|
|
|
|
function getParsingFlags(m) {
|
|
if (m._pf == null) {
|
|
m._pf = defaultParsingFlags();
|
|
}
|
|
return m._pf;
|
|
}
|
|
|
|
var some;
|
|
if (Array.prototype.some) {
|
|
some = Array.prototype.some;
|
|
} else {
|
|
some = function (fun) {
|
|
var t = Object(this),
|
|
len = t.length >>> 0,
|
|
i;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (i in t && fun.call(this, t[i], i, t)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
}
|
|
|
|
function isValid(m) {
|
|
var flags = null,
|
|
parsedParts = false,
|
|
isNowValid = m._d && !isNaN(m._d.getTime());
|
|
if (isNowValid) {
|
|
flags = getParsingFlags(m);
|
|
parsedParts = some.call(flags.parsedDateParts, function (i) {
|
|
return i != null;
|
|
});
|
|
isNowValid =
|
|
flags.overflow < 0 &&
|
|
!flags.empty &&
|
|
!flags.invalidEra &&
|
|
!flags.invalidMonth &&
|
|
!flags.invalidWeekday &&
|
|
!flags.weekdayMismatch &&
|
|
!flags.nullInput &&
|
|
!flags.invalidFormat &&
|
|
!flags.userInvalidated &&
|
|
(!flags.meridiem || (flags.meridiem && parsedParts));
|
|
if (m._strict) {
|
|
isNowValid =
|
|
isNowValid &&
|
|
flags.charsLeftOver === 0 &&
|
|
flags.unusedTokens.length === 0 &&
|
|
flags.bigHour === undefined;
|
|
}
|
|
}
|
|
if (Object.isFrozen == null || !Object.isFrozen(m)) {
|
|
m._isValid = isNowValid;
|
|
} else {
|
|
return isNowValid;
|
|
}
|
|
return m._isValid;
|
|
}
|
|
|
|
function createInvalid(flags) {
|
|
var m = createUTC(NaN);
|
|
if (flags != null) {
|
|
extend(getParsingFlags(m), flags);
|
|
} else {
|
|
getParsingFlags(m).userInvalidated = true;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
// Plugins that add properties should also add the key here (null value),
|
|
// so we can properly clone ourselves.
|
|
var momentProperties = (hooks.momentProperties = []),
|
|
updateInProgress = false;
|
|
|
|
function copyConfig(to, from) {
|
|
var i,
|
|
prop,
|
|
val,
|
|
momentPropertiesLen = momentProperties.length;
|
|
|
|
if (!isUndefined(from._isAMomentObject)) {
|
|
to._isAMomentObject = from._isAMomentObject;
|
|
}
|
|
if (!isUndefined(from._i)) {
|
|
to._i = from._i;
|
|
}
|
|
if (!isUndefined(from._f)) {
|
|
to._f = from._f;
|
|
}
|
|
if (!isUndefined(from._l)) {
|
|
to._l = from._l;
|
|
}
|
|
if (!isUndefined(from._strict)) {
|
|
to._strict = from._strict;
|
|
}
|
|
if (!isUndefined(from._tzm)) {
|
|
to._tzm = from._tzm;
|
|
}
|
|
if (!isUndefined(from._isUTC)) {
|
|
to._isUTC = from._isUTC;
|
|
}
|
|
if (!isUndefined(from._offset)) {
|
|
to._offset = from._offset;
|
|
}
|
|
if (!isUndefined(from._pf)) {
|
|
to._pf = getParsingFlags(from);
|
|
}
|
|
if (!isUndefined(from._locale)) {
|
|
to._locale = from._locale;
|
|
}
|
|
|
|
if (momentPropertiesLen > 0) {
|
|
for (i = 0; i < momentPropertiesLen; i++) {
|
|
prop = momentProperties[i];
|
|
val = from[prop];
|
|
if (!isUndefined(val)) {
|
|
to[prop] = val;
|
|
}
|
|
}
|
|
}
|
|
|
|
return to;
|
|
}
|
|
|
|
// Moment prototype object
|
|
function Moment(config) {
|
|
copyConfig(this, config);
|
|
this._d = new Date(config._d != null ? config._d.getTime() : NaN);
|
|
if (!this.isValid()) {
|
|
this._d = new Date(NaN);
|
|
}
|
|
// Prevent infinite loop in case updateOffset creates new moment
|
|
// objects.
|
|
if (updateInProgress === false) {
|
|
updateInProgress = true;
|
|
hooks.updateOffset(this);
|
|
updateInProgress = false;
|
|
}
|
|
}
|
|
|
|
function isMoment(obj) {
|
|
return (
|
|
obj instanceof Moment || (obj != null && obj._isAMomentObject != null)
|
|
);
|
|
}
|
|
|
|
function warn(msg) {
|
|
if (
|
|
hooks.suppressDeprecationWarnings === false &&
|
|
typeof console !== 'undefined' &&
|
|
console.warn
|
|
) {
|
|
console.warn('Deprecation warning: ' + msg);
|
|
}
|
|
}
|
|
|
|
function deprecate(msg, fn) {
|
|
var firstTime = true;
|
|
|
|
return extend(function () {
|
|
if (hooks.deprecationHandler != null) {
|
|
hooks.deprecationHandler(null, msg);
|
|
}
|
|
if (firstTime) {
|
|
var args = [],
|
|
arg,
|
|
i,
|
|
key,
|
|
argLen = arguments.length;
|
|
for (i = 0; i < argLen; i++) {
|
|
arg = '';
|
|
if (typeof arguments[i] === 'object') {
|
|
arg += '\n[' + i + '] ';
|
|
for (key in arguments[0]) {
|
|
if (hasOwnProp(arguments[0], key)) {
|
|
arg += key + ': ' + arguments[0][key] + ', ';
|
|
}
|
|
}
|
|
arg = arg.slice(0, -2); // Remove trailing comma and space
|
|
} else {
|
|
arg = arguments[i];
|
|
}
|
|
args.push(arg);
|
|
}
|
|
warn(
|
|
msg +
|
|
'\nArguments: ' +
|
|
Array.prototype.slice.call(args).join('') +
|
|
'\n' +
|
|
new Error().stack
|
|
);
|
|
firstTime = false;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}, fn);
|
|
}
|
|
|
|
var deprecations = {};
|
|
|
|
function deprecateSimple(name, msg) {
|
|
if (hooks.deprecationHandler != null) {
|
|
hooks.deprecationHandler(name, msg);
|
|
}
|
|
if (!deprecations[name]) {
|
|
warn(msg);
|
|
deprecations[name] = true;
|
|
}
|
|
}
|
|
|
|
hooks.suppressDeprecationWarnings = false;
|
|
hooks.deprecationHandler = null;
|
|
|
|
function isFunction(input) {
|
|
return (
|
|
(typeof Function !== 'undefined' && input instanceof Function) ||
|
|
Object.prototype.toString.call(input) === '[object Function]'
|
|
);
|
|
}
|
|
|
|
function set(config) {
|
|
var prop, i;
|
|
for (i in config) {
|
|
if (hasOwnProp(config, i)) {
|
|
prop = config[i];
|
|
if (isFunction(prop)) {
|
|
this[i] = prop;
|
|
} else {
|
|
this['_' + i] = prop;
|
|
}
|
|
}
|
|
}
|
|
this._config = config;
|
|
// Lenient ordinal parsing accepts just a number in addition to
|
|
// number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
|
|
// TODO: Remove "ordinalParse" fallback in next major release.
|
|
this._dayOfMonthOrdinalParseLenient = new RegExp(
|
|
(this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
|
|
'|' +
|
|
/\d{1,2}/.source
|
|
);
|
|
}
|
|
|
|
function mergeConfigs(parentConfig, childConfig) {
|
|
var res = extend({}, parentConfig),
|
|
prop;
|
|
for (prop in childConfig) {
|
|
if (hasOwnProp(childConfig, prop)) {
|
|
if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
|
|
res[prop] = {};
|
|
extend(res[prop], parentConfig[prop]);
|
|
extend(res[prop], childConfig[prop]);
|
|
} else if (childConfig[prop] != null) {
|
|
res[prop] = childConfig[prop];
|
|
} else {
|
|
delete res[prop];
|
|
}
|
|
}
|
|
}
|
|
for (prop in parentConfig) {
|
|
if (
|
|
hasOwnProp(parentConfig, prop) &&
|
|
!hasOwnProp(childConfig, prop) &&
|
|
isObject(parentConfig[prop])
|
|
) {
|
|
// make sure changes to properties don't modify parent config
|
|
res[prop] = extend({}, res[prop]);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function Locale(config) {
|
|
if (config != null) {
|
|
this.set(config);
|
|
}
|
|
}
|
|
|
|
var keys;
|
|
|
|
if (Object.keys) {
|
|
keys = Object.keys;
|
|
} else {
|
|
keys = function (obj) {
|
|
var i,
|
|
res = [];
|
|
for (i in obj) {
|
|
if (hasOwnProp(obj, i)) {
|
|
res.push(i);
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
|
|
var defaultCalendar = {
|
|
sameDay: '[Today at] LT',
|
|
nextDay: '[Tomorrow at] LT',
|
|
nextWeek: 'dddd [at] LT',
|
|
lastDay: '[Yesterday at] LT',
|
|
lastWeek: '[Last] dddd [at] LT',
|
|
sameElse: 'L',
|
|
};
|
|
|
|
function calendar(key, mom, now) {
|
|
var output = this._calendar[key] || this._calendar['sameElse'];
|
|
return isFunction(output) ? output.call(mom, now) : output;
|
|
}
|
|
|
|
function zeroFill(number, targetLength, forceSign) {
|
|
var absNumber = '' + Math.abs(number),
|
|
zerosToFill = targetLength - absNumber.length,
|
|
sign = number >= 0;
|
|
return (
|
|
(sign ? (forceSign ? '+' : '') : '-') +
|
|
Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) +
|
|
absNumber
|
|
);
|
|
}
|
|
|
|
var formattingTokens =
|
|
/(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g,
|
|
localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g,
|
|
formatFunctions = {},
|
|
formatTokenFunctions = {};
|
|
|
|
// token: 'M'
|
|
// padded: ['MM', 2]
|
|
// ordinal: 'Mo'
|
|
// callback: function () { this.month() + 1 }
|
|
function addFormatToken(token, padded, ordinal, callback) {
|
|
var func = callback;
|
|
if (typeof callback === 'string') {
|
|
func = function () {
|
|
return this[callback]();
|
|
};
|
|
}
|
|
if (token) {
|
|
formatTokenFunctions[token] = func;
|
|
}
|
|
if (padded) {
|
|
formatTokenFunctions[padded[0]] = function () {
|
|
return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
|
|
};
|
|
}
|
|
if (ordinal) {
|
|
formatTokenFunctions[ordinal] = function () {
|
|
return this.localeData().ordinal(
|
|
func.apply(this, arguments),
|
|
token
|
|
);
|
|
};
|
|
}
|
|
}
|
|
|
|
function removeFormattingTokens(input) {
|
|
if (input.match(/\[[\s\S]/)) {
|
|
return input.replace(/^\[|\]$/g, '');
|
|
}
|
|
return input.replace(/\\/g, '');
|
|
}
|
|
|
|
function makeFormatFunction(format) {
|
|
var array = format.match(formattingTokens),
|
|
i,
|
|
length;
|
|
|
|
for (i = 0, length = array.length; i < length; i++) {
|
|
if (formatTokenFunctions[array[i]]) {
|
|
array[i] = formatTokenFunctions[array[i]];
|
|
} else {
|
|
array[i] = removeFormattingTokens(array[i]);
|
|
}
|
|
}
|
|
|
|
return function (mom) {
|
|
var output = '',
|
|
i;
|
|
for (i = 0; i < length; i++) {
|
|
output += isFunction(array[i])
|
|
? array[i].call(mom, format)
|
|
: array[i];
|
|
}
|
|
return output;
|
|
};
|
|
}
|
|
|
|
// format date using native date object
|
|
function formatMoment(m, format) {
|
|
if (!m.isValid()) {
|
|
return m.localeData().invalidDate();
|
|
}
|
|
|
|
format = expandFormat(format, m.localeData());
|
|
formatFunctions[format] =
|
|
formatFunctions[format] || makeFormatFunction(format);
|
|
|
|
return formatFunctions[format](m);
|
|
}
|
|
|
|
function expandFormat(format, locale) {
|
|
var i = 5;
|
|
|
|
function replaceLongDateFormatTokens(input) {
|
|
return locale.longDateFormat(input) || input;
|
|
}
|
|
|
|
localFormattingTokens.lastIndex = 0;
|
|
while (i >= 0 && localFormattingTokens.test(format)) {
|
|
format = format.replace(
|
|
localFormattingTokens,
|
|
replaceLongDateFormatTokens
|
|
);
|
|
localFormattingTokens.lastIndex = 0;
|
|
i -= 1;
|
|
}
|
|
|
|
return format;
|
|
}
|
|
|
|
var defaultLongDateFormat = {
|
|
LTS: 'h:mm:ss A',
|
|
LT: 'h:mm A',
|
|
L: 'MM/DD/YYYY',
|
|
LL: 'MMMM D, YYYY',
|
|
LLL: 'MMMM D, YYYY h:mm A',
|
|
LLLL: 'dddd, MMMM D, YYYY h:mm A',
|
|
};
|
|
|
|
function longDateFormat(key) {
|
|
var format = this._longDateFormat[key],
|
|
formatUpper = this._longDateFormat[key.toUpperCase()];
|
|
|
|
if (format || !formatUpper) {
|
|
return format;
|
|
}
|
|
|
|
this._longDateFormat[key] = formatUpper
|
|
.match(formattingTokens)
|
|
.map(function (tok) {
|
|
if (
|
|
tok === 'MMMM' ||
|
|
tok === 'MM' ||
|
|
tok === 'DD' ||
|
|
tok === 'dddd'
|
|
) {
|
|
return tok.slice(1);
|
|
}
|
|
return tok;
|
|
})
|
|
.join('');
|
|
|
|
return this._longDateFormat[key];
|
|
}
|
|
|
|
var defaultInvalidDate = 'Invalid date';
|
|
|
|
function invalidDate() {
|
|
return this._invalidDate;
|
|
}
|
|
|
|
var defaultOrdinal = '%d',
|
|
defaultDayOfMonthOrdinalParse = /\d{1,2}/;
|
|
|
|
function ordinal(number) {
|
|
return this._ordinal.replace('%d', number);
|
|
}
|
|
|
|
var defaultRelativeTime = {
|
|
future: 'in %s',
|
|
past: '%s ago',
|
|
s: 'a few seconds',
|
|
ss: '%d seconds',
|
|
m: 'a minute',
|
|
mm: '%d minutes',
|
|
h: 'an hour',
|
|
hh: '%d hours',
|
|
d: 'a day',
|
|
dd: '%d days',
|
|
w: 'a week',
|
|
ww: '%d weeks',
|
|
M: 'a month',
|
|
MM: '%d months',
|
|
y: 'a year',
|
|
yy: '%d years',
|
|
};
|
|
|
|
function relativeTime(number, withoutSuffix, string, isFuture) {
|
|
var output = this._relativeTime[string];
|
|
return isFunction(output)
|
|
? output(number, withoutSuffix, string, isFuture)
|
|
: output.replace(/%d/i, number);
|
|
}
|
|
|
|
function pastFuture(diff, output) {
|
|
var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
|
|
return isFunction(format) ? format(output) : format.replace(/%s/i, output);
|
|
}
|
|
|
|
var aliases = {
|
|
D: 'date',
|
|
dates: 'date',
|
|
date: 'date',
|
|
d: 'day',
|
|
days: 'day',
|
|
day: 'day',
|
|
e: 'weekday',
|
|
weekdays: 'weekday',
|
|
weekday: 'weekday',
|
|
E: 'isoWeekday',
|
|
isoweekdays: 'isoWeekday',
|
|
isoweekday: 'isoWeekday',
|
|
DDD: 'dayOfYear',
|
|
dayofyears: 'dayOfYear',
|
|
dayofyear: 'dayOfYear',
|
|
h: 'hour',
|
|
hours: 'hour',
|
|
hour: 'hour',
|
|
ms: 'millisecond',
|
|
milliseconds: 'millisecond',
|
|
millisecond: 'millisecond',
|
|
m: 'minute',
|
|
minutes: 'minute',
|
|
minute: 'minute',
|
|
M: 'month',
|
|
months: 'month',
|
|
month: 'month',
|
|
Q: 'quarter',
|
|
quarters: 'quarter',
|
|
quarter: 'quarter',
|
|
s: 'second',
|
|
seconds: 'second',
|
|
second: 'second',
|
|
gg: 'weekYear',
|
|
weekyears: 'weekYear',
|
|
weekyear: 'weekYear',
|
|
GG: 'isoWeekYear',
|
|
isoweekyears: 'isoWeekYear',
|
|
isoweekyear: 'isoWeekYear',
|
|
w: 'week',
|
|
weeks: 'week',
|
|
week: 'week',
|
|
W: 'isoWeek',
|
|
isoweeks: 'isoWeek',
|
|
isoweek: 'isoWeek',
|
|
y: 'year',
|
|
years: 'year',
|
|
year: 'year',
|
|
};
|
|
|
|
function normalizeUnits(units) {
|
|
return typeof units === 'string'
|
|
? aliases[units] || aliases[units.toLowerCase()]
|
|
: undefined;
|
|
}
|
|
|
|
function normalizeObjectUnits(inputObject) {
|
|
var normalizedInput = {},
|
|
normalizedProp,
|
|
prop;
|
|
|
|
for (prop in inputObject) {
|
|
if (hasOwnProp(inputObject, prop)) {
|
|
normalizedProp = normalizeUnits(prop);
|
|
if (normalizedProp) {
|
|
normalizedInput[normalizedProp] = inputObject[prop];
|
|
}
|
|
}
|
|
}
|
|
|
|
return normalizedInput;
|
|
}
|
|
|
|
var priorities = {
|
|
date: 9,
|
|
day: 11,
|
|
weekday: 11,
|
|
isoWeekday: 11,
|
|
dayOfYear: 4,
|
|
hour: 13,
|
|
millisecond: 16,
|
|
minute: 14,
|
|
month: 8,
|
|
quarter: 7,
|
|
second: 15,
|
|
weekYear: 1,
|
|
isoWeekYear: 1,
|
|
week: 5,
|
|
isoWeek: 5,
|
|
year: 1,
|
|
};
|
|
|
|
function getPrioritizedUnits(unitsObj) {
|
|
var units = [],
|
|
u;
|
|
for (u in unitsObj) {
|
|
if (hasOwnProp(unitsObj, u)) {
|
|
units.push({ unit: u, priority: priorities[u] });
|
|
}
|
|
}
|
|
units.sort(function (a, b) {
|
|
return a.priority - b.priority;
|
|
});
|
|
return units;
|
|
}
|
|
|
|
var match1 = /\d/, // 0 - 9
|
|
match2 = /\d\d/, // 00 - 99
|
|
match3 = /\d{3}/, // 000 - 999
|
|
match4 = /\d{4}/, // 0000 - 9999
|
|
match6 = /[+-]?\d{6}/, // -999999 - 999999
|
|
match1to2 = /\d\d?/, // 0 - 99
|
|
match3to4 = /\d\d\d\d?/, // 999 - 9999
|
|
match5to6 = /\d\d\d\d\d\d?/, // 99999 - 999999
|
|
match1to3 = /\d{1,3}/, // 0 - 999
|
|
match1to4 = /\d{1,4}/, // 0 - 9999
|
|
match1to6 = /[+-]?\d{1,6}/, // -999999 - 999999
|
|
matchUnsigned = /\d+/, // 0 - inf
|
|
matchSigned = /[+-]?\d+/, // -inf - inf
|
|
matchOffset = /Z|[+-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
|
|
matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, // +00 -00 +00:00 -00:00 +0000 -0000 or Z
|
|
matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
|
|
// any word (or two) characters or numbers including two/three word month in arabic.
|
|
// includes scottish gaelic two word and hyphenated months
|
|
matchWord =
|
|
/[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
|
|
match1to2NoLeadingZero = /^[1-9]\d?/, // 1-99
|
|
match1to2HasZero = /^([1-9]\d|\d)/, // 0-99
|
|
regexes;
|
|
|
|
regexes = {};
|
|
|
|
function addRegexToken(token, regex, strictRegex) {
|
|
regexes[token] = isFunction(regex)
|
|
? regex
|
|
: function (isStrict, localeData) {
|
|
return isStrict && strictRegex ? strictRegex : regex;
|
|
};
|
|
}
|
|
|
|
function getParseRegexForToken(token, config) {
|
|
if (!hasOwnProp(regexes, token)) {
|
|
return new RegExp(unescapeFormat(token));
|
|
}
|
|
|
|
return regexes[token](config._strict, config._locale);
|
|
}
|
|
|
|
// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
|
|
function unescapeFormat(s) {
|
|
return regexEscape(
|
|
s
|
|
.replace('\\', '')
|
|
.replace(
|
|
/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,
|
|
function (matched, p1, p2, p3, p4) {
|
|
return p1 || p2 || p3 || p4;
|
|
}
|
|
)
|
|
);
|
|
}
|
|
|
|
function regexEscape(s) {
|
|
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
|
|
}
|
|
|
|
function absFloor(number) {
|
|
if (number < 0) {
|
|
// -0 -> 0
|
|
return Math.ceil(number) || 0;
|
|
} else {
|
|
return Math.floor(number);
|
|
}
|
|
}
|
|
|
|
function toInt(argumentForCoercion) {
|
|
var coercedNumber = +argumentForCoercion,
|
|
value = 0;
|
|
|
|
if (coercedNumber !== 0 && isFinite(coercedNumber)) {
|
|
value = absFloor(coercedNumber);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
var tokens = {};
|
|
|
|
function addParseToken(token, callback) {
|
|
var i,
|
|
func = callback,
|
|
tokenLen;
|
|
if (typeof token === 'string') {
|
|
token = [token];
|
|
}
|
|
if (isNumber(callback)) {
|
|
func = function (input, array) {
|
|
array[callback] = toInt(input);
|
|
};
|
|
}
|
|
tokenLen = token.length;
|
|
for (i = 0; i < tokenLen; i++) {
|
|
tokens[token[i]] = func;
|
|
}
|
|
}
|
|
|
|
function addWeekParseToken(token, callback) {
|
|
addParseToken(token, function (input, array, config, token) {
|
|
config._w = config._w || {};
|
|
callback(input, config._w, config, token);
|
|
});
|
|
}
|
|
|
|
function addTimeToArrayFromToken(token, input, config) {
|
|
if (input != null && hasOwnProp(tokens, token)) {
|
|
tokens[token](input, config._a, config, token);
|
|
}
|
|
}
|
|
|
|
function isLeapYear(year) {
|
|
return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
|
|
}
|
|
|
|
var YEAR = 0,
|
|
MONTH = 1,
|
|
DATE = 2,
|
|
HOUR = 3,
|
|
MINUTE = 4,
|
|
SECOND = 5,
|
|
MILLISECOND = 6,
|
|
WEEK = 7,
|
|
WEEKDAY = 8;
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('Y', 0, 0, function () {
|
|
var y = this.year();
|
|
return y <= 9999 ? zeroFill(y, 4) : '+' + y;
|
|
});
|
|
|
|
addFormatToken(0, ['YY', 2], 0, function () {
|
|
return this.year() % 100;
|
|
});
|
|
|
|
addFormatToken(0, ['YYYY', 4], 0, 'year');
|
|
addFormatToken(0, ['YYYYY', 5], 0, 'year');
|
|
addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('Y', matchSigned);
|
|
addRegexToken('YY', match1to2, match2);
|
|
addRegexToken('YYYY', match1to4, match4);
|
|
addRegexToken('YYYYY', match1to6, match6);
|
|
addRegexToken('YYYYYY', match1to6, match6);
|
|
|
|
addParseToken(['YYYYY', 'YYYYYY'], YEAR);
|
|
addParseToken('YYYY', function (input, array) {
|
|
array[YEAR] =
|
|
input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
|
|
});
|
|
addParseToken('YY', function (input, array) {
|
|
array[YEAR] = hooks.parseTwoDigitYear(input);
|
|
});
|
|
addParseToken('Y', function (input, array) {
|
|
array[YEAR] = parseInt(input, 10);
|
|
});
|
|
|
|
// HELPERS
|
|
|
|
function daysInYear(year) {
|
|
return isLeapYear(year) ? 366 : 365;
|
|
}
|
|
|
|
// HOOKS
|
|
|
|
hooks.parseTwoDigitYear = function (input) {
|
|
return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
|
|
};
|
|
|
|
// MOMENTS
|
|
|
|
var getSetYear = makeGetSet('FullYear', true);
|
|
|
|
function getIsLeapYear() {
|
|
return isLeapYear(this.year());
|
|
}
|
|
|
|
function makeGetSet(unit, keepTime) {
|
|
return function (value) {
|
|
if (value != null) {
|
|
set$1(this, unit, value);
|
|
hooks.updateOffset(this, keepTime);
|
|
return this;
|
|
} else {
|
|
return get(this, unit);
|
|
}
|
|
};
|
|
}
|
|
|
|
function get(mom, unit) {
|
|
if (!mom.isValid()) {
|
|
return NaN;
|
|
}
|
|
|
|
var d = mom._d,
|
|
isUTC = mom._isUTC;
|
|
|
|
switch (unit) {
|
|
case 'Milliseconds':
|
|
return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds();
|
|
case 'Seconds':
|
|
return isUTC ? d.getUTCSeconds() : d.getSeconds();
|
|
case 'Minutes':
|
|
return isUTC ? d.getUTCMinutes() : d.getMinutes();
|
|
case 'Hours':
|
|
return isUTC ? d.getUTCHours() : d.getHours();
|
|
case 'Date':
|
|
return isUTC ? d.getUTCDate() : d.getDate();
|
|
case 'Day':
|
|
return isUTC ? d.getUTCDay() : d.getDay();
|
|
case 'Month':
|
|
return isUTC ? d.getUTCMonth() : d.getMonth();
|
|
case 'FullYear':
|
|
return isUTC ? d.getUTCFullYear() : d.getFullYear();
|
|
default:
|
|
return NaN; // Just in case
|
|
}
|
|
}
|
|
|
|
function set$1(mom, unit, value) {
|
|
var d, isUTC, year, month, date;
|
|
|
|
if (!mom.isValid() || isNaN(value)) {
|
|
return;
|
|
}
|
|
|
|
d = mom._d;
|
|
isUTC = mom._isUTC;
|
|
|
|
switch (unit) {
|
|
case 'Milliseconds':
|
|
return void (isUTC
|
|
? d.setUTCMilliseconds(value)
|
|
: d.setMilliseconds(value));
|
|
case 'Seconds':
|
|
return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value));
|
|
case 'Minutes':
|
|
return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value));
|
|
case 'Hours':
|
|
return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
|
|
case 'Date':
|
|
return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
|
|
// case 'Day': // Not real
|
|
// return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
|
|
// case 'Month': // Not used because we need to pass two variables
|
|
// return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
|
|
case 'FullYear':
|
|
break; // See below ...
|
|
default:
|
|
return; // Just in case
|
|
}
|
|
|
|
year = value;
|
|
month = mom.month();
|
|
date = mom.date();
|
|
date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
|
|
void (isUTC
|
|
? d.setUTCFullYear(year, month, date)
|
|
: d.setFullYear(year, month, date));
|
|
}
|
|
|
|
// MOMENTS
|
|
|
|
function stringGet(units) {
|
|
units = normalizeUnits(units);
|
|
if (isFunction(this[units])) {
|
|
return this[units]();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
function stringSet(units, value) {
|
|
if (typeof units === 'object') {
|
|
units = normalizeObjectUnits(units);
|
|
var prioritized = getPrioritizedUnits(units),
|
|
i,
|
|
prioritizedLen = prioritized.length;
|
|
for (i = 0; i < prioritizedLen; i++) {
|
|
this[prioritized[i].unit](units[prioritized[i].unit]);
|
|
}
|
|
} else {
|
|
units = normalizeUnits(units);
|
|
if (isFunction(this[units])) {
|
|
return this[units](value);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
function mod(n, x) {
|
|
return ((n % x) + x) % x;
|
|
}
|
|
|
|
var indexOf;
|
|
|
|
if (Array.prototype.indexOf) {
|
|
indexOf = Array.prototype.indexOf;
|
|
} else {
|
|
indexOf = function (o) {
|
|
// I know
|
|
var i;
|
|
for (i = 0; i < this.length; ++i) {
|
|
if (this[i] === o) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
}
|
|
|
|
function daysInMonth(year, month) {
|
|
if (isNaN(year) || isNaN(month)) {
|
|
return NaN;
|
|
}
|
|
var modMonth = mod(month, 12);
|
|
year += (month - modMonth) / 12;
|
|
return modMonth === 1
|
|
? isLeapYear(year)
|
|
? 29
|
|
: 28
|
|
: 31 - ((modMonth % 7) % 2);
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('M', ['MM', 2], 'Mo', function () {
|
|
return this.month() + 1;
|
|
});
|
|
|
|
addFormatToken('MMM', 0, 0, function (format) {
|
|
return this.localeData().monthsShort(this, format);
|
|
});
|
|
|
|
addFormatToken('MMMM', 0, 0, function (format) {
|
|
return this.localeData().months(this, format);
|
|
});
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('M', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('MM', match1to2, match2);
|
|
addRegexToken('MMM', function (isStrict, locale) {
|
|
return locale.monthsShortRegex(isStrict);
|
|
});
|
|
addRegexToken('MMMM', function (isStrict, locale) {
|
|
return locale.monthsRegex(isStrict);
|
|
});
|
|
|
|
addParseToken(['M', 'MM'], function (input, array) {
|
|
array[MONTH] = toInt(input) - 1;
|
|
});
|
|
|
|
addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
|
|
var month = config._locale.monthsParse(input, token, config._strict);
|
|
// if we didn't find a month name, mark the date as invalid.
|
|
if (month != null) {
|
|
array[MONTH] = month;
|
|
} else {
|
|
getParsingFlags(config).invalidMonth = input;
|
|
}
|
|
});
|
|
|
|
// LOCALES
|
|
|
|
var defaultLocaleMonths =
|
|
'January_February_March_April_May_June_July_August_September_October_November_December'.split(
|
|
'_'
|
|
),
|
|
defaultLocaleMonthsShort =
|
|
'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
|
|
MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/,
|
|
defaultMonthsShortRegex = matchWord,
|
|
defaultMonthsRegex = matchWord;
|
|
|
|
function localeMonths(m, format) {
|
|
if (!m) {
|
|
return isArray(this._months)
|
|
? this._months
|
|
: this._months['standalone'];
|
|
}
|
|
return isArray(this._months)
|
|
? this._months[m.month()]
|
|
: this._months[
|
|
(this._months.isFormat || MONTHS_IN_FORMAT).test(format)
|
|
? 'format'
|
|
: 'standalone'
|
|
][m.month()];
|
|
}
|
|
|
|
function localeMonthsShort(m, format) {
|
|
if (!m) {
|
|
return isArray(this._monthsShort)
|
|
? this._monthsShort
|
|
: this._monthsShort['standalone'];
|
|
}
|
|
return isArray(this._monthsShort)
|
|
? this._monthsShort[m.month()]
|
|
: this._monthsShort[
|
|
MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'
|
|
][m.month()];
|
|
}
|
|
|
|
function handleStrictParse(monthName, format, strict) {
|
|
var i,
|
|
ii,
|
|
mom,
|
|
llc = monthName.toLocaleLowerCase();
|
|
if (!this._monthsParse) {
|
|
// this is not used
|
|
this._monthsParse = [];
|
|
this._longMonthsParse = [];
|
|
this._shortMonthsParse = [];
|
|
for (i = 0; i < 12; ++i) {
|
|
mom = createUTC([2000, i]);
|
|
this._shortMonthsParse[i] = this.monthsShort(
|
|
mom,
|
|
''
|
|
).toLocaleLowerCase();
|
|
this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
|
|
}
|
|
}
|
|
|
|
if (strict) {
|
|
if (format === 'MMM') {
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
} else {
|
|
if (format === 'MMM') {
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._longMonthsParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortMonthsParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
}
|
|
}
|
|
|
|
function localeMonthsParse(monthName, format, strict) {
|
|
var i, mom, regex;
|
|
|
|
if (this._monthsParseExact) {
|
|
return handleStrictParse.call(this, monthName, format, strict);
|
|
}
|
|
|
|
if (!this._monthsParse) {
|
|
this._monthsParse = [];
|
|
this._longMonthsParse = [];
|
|
this._shortMonthsParse = [];
|
|
}
|
|
|
|
// TODO: add sorting
|
|
// Sorting makes sure if one month (or abbr) is a prefix of another
|
|
// see sorting in computeMonthsParse
|
|
for (i = 0; i < 12; i++) {
|
|
// make the regex if we don't have it already
|
|
mom = createUTC([2000, i]);
|
|
if (strict && !this._longMonthsParse[i]) {
|
|
this._longMonthsParse[i] = new RegExp(
|
|
'^' + this.months(mom, '').replace('.', '') + '$',
|
|
'i'
|
|
);
|
|
this._shortMonthsParse[i] = new RegExp(
|
|
'^' + this.monthsShort(mom, '').replace('.', '') + '$',
|
|
'i'
|
|
);
|
|
}
|
|
if (!strict && !this._monthsParse[i]) {
|
|
regex =
|
|
'^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
|
|
this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
|
|
}
|
|
// test the regex
|
|
if (
|
|
strict &&
|
|
format === 'MMMM' &&
|
|
this._longMonthsParse[i].test(monthName)
|
|
) {
|
|
return i;
|
|
} else if (
|
|
strict &&
|
|
format === 'MMM' &&
|
|
this._shortMonthsParse[i].test(monthName)
|
|
) {
|
|
return i;
|
|
} else if (!strict && this._monthsParse[i].test(monthName)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// MOMENTS
|
|
|
|
function setMonth(mom, value) {
|
|
if (!mom.isValid()) {
|
|
// No op
|
|
return mom;
|
|
}
|
|
|
|
if (typeof value === 'string') {
|
|
if (/^\d+$/.test(value)) {
|
|
value = toInt(value);
|
|
} else {
|
|
value = mom.localeData().monthsParse(value);
|
|
// TODO: Another silent failure?
|
|
if (!isNumber(value)) {
|
|
return mom;
|
|
}
|
|
}
|
|
}
|
|
|
|
var month = value,
|
|
date = mom.date();
|
|
|
|
date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
|
|
void (mom._isUTC
|
|
? mom._d.setUTCMonth(month, date)
|
|
: mom._d.setMonth(month, date));
|
|
return mom;
|
|
}
|
|
|
|
function getSetMonth(value) {
|
|
if (value != null) {
|
|
setMonth(this, value);
|
|
hooks.updateOffset(this, true);
|
|
return this;
|
|
} else {
|
|
return get(this, 'Month');
|
|
}
|
|
}
|
|
|
|
function getDaysInMonth() {
|
|
return daysInMonth(this.year(), this.month());
|
|
}
|
|
|
|
function monthsShortRegex(isStrict) {
|
|
if (this._monthsParseExact) {
|
|
if (!hasOwnProp(this, '_monthsRegex')) {
|
|
computeMonthsParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._monthsShortStrictRegex;
|
|
} else {
|
|
return this._monthsShortRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, '_monthsShortRegex')) {
|
|
this._monthsShortRegex = defaultMonthsShortRegex;
|
|
}
|
|
return this._monthsShortStrictRegex && isStrict
|
|
? this._monthsShortStrictRegex
|
|
: this._monthsShortRegex;
|
|
}
|
|
}
|
|
|
|
function monthsRegex(isStrict) {
|
|
if (this._monthsParseExact) {
|
|
if (!hasOwnProp(this, '_monthsRegex')) {
|
|
computeMonthsParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._monthsStrictRegex;
|
|
} else {
|
|
return this._monthsRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, '_monthsRegex')) {
|
|
this._monthsRegex = defaultMonthsRegex;
|
|
}
|
|
return this._monthsStrictRegex && isStrict
|
|
? this._monthsStrictRegex
|
|
: this._monthsRegex;
|
|
}
|
|
}
|
|
|
|
function computeMonthsParse() {
|
|
function cmpLenRev(a, b) {
|
|
return b.length - a.length;
|
|
}
|
|
|
|
var shortPieces = [],
|
|
longPieces = [],
|
|
mixedPieces = [],
|
|
i,
|
|
mom,
|
|
shortP,
|
|
longP;
|
|
for (i = 0; i < 12; i++) {
|
|
// make the regex if we don't have it already
|
|
mom = createUTC([2000, i]);
|
|
shortP = regexEscape(this.monthsShort(mom, ''));
|
|
longP = regexEscape(this.months(mom, ''));
|
|
shortPieces.push(shortP);
|
|
longPieces.push(longP);
|
|
mixedPieces.push(longP);
|
|
mixedPieces.push(shortP);
|
|
}
|
|
// Sorting makes sure if one month (or abbr) is a prefix of another it
|
|
// will match the longer piece.
|
|
shortPieces.sort(cmpLenRev);
|
|
longPieces.sort(cmpLenRev);
|
|
mixedPieces.sort(cmpLenRev);
|
|
|
|
this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
|
|
this._monthsShortRegex = this._monthsRegex;
|
|
this._monthsStrictRegex = new RegExp(
|
|
'^(' + longPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
this._monthsShortStrictRegex = new RegExp(
|
|
'^(' + shortPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
}
|
|
|
|
function createDate(y, m, d, h, M, s, ms) {
|
|
// can't just apply() to create a date:
|
|
// https://stackoverflow.com/q/181348
|
|
var date;
|
|
// the date constructor remaps years 0-99 to 1900-1999
|
|
if (y < 100 && y >= 0) {
|
|
// preserve leap years using a full 400 year cycle, then reset
|
|
date = new Date(y + 400, m, d, h, M, s, ms);
|
|
if (isFinite(date.getFullYear())) {
|
|
date.setFullYear(y);
|
|
}
|
|
} else {
|
|
date = new Date(y, m, d, h, M, s, ms);
|
|
}
|
|
|
|
return date;
|
|
}
|
|
|
|
function createUTCDate(y) {
|
|
var date, args;
|
|
// the Date.UTC function remaps years 0-99 to 1900-1999
|
|
if (y < 100 && y >= 0) {
|
|
args = Array.prototype.slice.call(arguments);
|
|
// preserve leap years using a full 400 year cycle, then reset
|
|
args[0] = y + 400;
|
|
date = new Date(Date.UTC.apply(null, args));
|
|
if (isFinite(date.getUTCFullYear())) {
|
|
date.setUTCFullYear(y);
|
|
}
|
|
} else {
|
|
date = new Date(Date.UTC.apply(null, arguments));
|
|
}
|
|
|
|
return date;
|
|
}
|
|
|
|
// start-of-first-week - start-of-year
|
|
function firstWeekOffset(year, dow, doy) {
|
|
var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
|
|
fwd = 7 + dow - doy,
|
|
// first-week day local weekday -- which local weekday is fwd
|
|
fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
|
|
|
|
return -fwdlw + fwd - 1;
|
|
}
|
|
|
|
// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
|
|
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
|
|
var localWeekday = (7 + weekday - dow) % 7,
|
|
weekOffset = firstWeekOffset(year, dow, doy),
|
|
dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
|
|
resYear,
|
|
resDayOfYear;
|
|
|
|
if (dayOfYear <= 0) {
|
|
resYear = year - 1;
|
|
resDayOfYear = daysInYear(resYear) + dayOfYear;
|
|
} else if (dayOfYear > daysInYear(year)) {
|
|
resYear = year + 1;
|
|
resDayOfYear = dayOfYear - daysInYear(year);
|
|
} else {
|
|
resYear = year;
|
|
resDayOfYear = dayOfYear;
|
|
}
|
|
|
|
return {
|
|
year: resYear,
|
|
dayOfYear: resDayOfYear,
|
|
};
|
|
}
|
|
|
|
function weekOfYear(mom, dow, doy) {
|
|
var weekOffset = firstWeekOffset(mom.year(), dow, doy),
|
|
week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
|
|
resWeek,
|
|
resYear;
|
|
|
|
if (week < 1) {
|
|
resYear = mom.year() - 1;
|
|
resWeek = week + weeksInYear(resYear, dow, doy);
|
|
} else if (week > weeksInYear(mom.year(), dow, doy)) {
|
|
resWeek = week - weeksInYear(mom.year(), dow, doy);
|
|
resYear = mom.year() + 1;
|
|
} else {
|
|
resYear = mom.year();
|
|
resWeek = week;
|
|
}
|
|
|
|
return {
|
|
week: resWeek,
|
|
year: resYear,
|
|
};
|
|
}
|
|
|
|
function weeksInYear(year, dow, doy) {
|
|
var weekOffset = firstWeekOffset(year, dow, doy),
|
|
weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
|
|
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('w', ['ww', 2], 'wo', 'week');
|
|
addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('w', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('ww', match1to2, match2);
|
|
addRegexToken('W', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('WW', match1to2, match2);
|
|
|
|
addWeekParseToken(
|
|
['w', 'ww', 'W', 'WW'],
|
|
function (input, week, config, token) {
|
|
week[token.substr(0, 1)] = toInt(input);
|
|
}
|
|
);
|
|
|
|
// HELPERS
|
|
|
|
// LOCALES
|
|
|
|
function localeWeek(mom) {
|
|
return weekOfYear(mom, this._week.dow, this._week.doy).week;
|
|
}
|
|
|
|
var defaultLocaleWeek = {
|
|
dow: 0, // Sunday is the first day of the week.
|
|
doy: 6, // The week that contains Jan 6th is the first week of the year.
|
|
};
|
|
|
|
function localeFirstDayOfWeek() {
|
|
return this._week.dow;
|
|
}
|
|
|
|
function localeFirstDayOfYear() {
|
|
return this._week.doy;
|
|
}
|
|
|
|
// MOMENTS
|
|
|
|
function getSetWeek(input) {
|
|
var week = this.localeData().week(this);
|
|
return input == null ? week : this.add((input - week) * 7, 'd');
|
|
}
|
|
|
|
function getSetISOWeek(input) {
|
|
var week = weekOfYear(this, 1, 4).week;
|
|
return input == null ? week : this.add((input - week) * 7, 'd');
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('d', 0, 'do', 'day');
|
|
|
|
addFormatToken('dd', 0, 0, function (format) {
|
|
return this.localeData().weekdaysMin(this, format);
|
|
});
|
|
|
|
addFormatToken('ddd', 0, 0, function (format) {
|
|
return this.localeData().weekdaysShort(this, format);
|
|
});
|
|
|
|
addFormatToken('dddd', 0, 0, function (format) {
|
|
return this.localeData().weekdays(this, format);
|
|
});
|
|
|
|
addFormatToken('e', 0, 0, 'weekday');
|
|
addFormatToken('E', 0, 0, 'isoWeekday');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('d', match1to2);
|
|
addRegexToken('e', match1to2);
|
|
addRegexToken('E', match1to2);
|
|
addRegexToken('dd', function (isStrict, locale) {
|
|
return locale.weekdaysMinRegex(isStrict);
|
|
});
|
|
addRegexToken('ddd', function (isStrict, locale) {
|
|
return locale.weekdaysShortRegex(isStrict);
|
|
});
|
|
addRegexToken('dddd', function (isStrict, locale) {
|
|
return locale.weekdaysRegex(isStrict);
|
|
});
|
|
|
|
addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
|
|
var weekday = config._locale.weekdaysParse(input, token, config._strict);
|
|
// if we didn't get a weekday name, mark the date as invalid
|
|
if (weekday != null) {
|
|
week.d = weekday;
|
|
} else {
|
|
getParsingFlags(config).invalidWeekday = input;
|
|
}
|
|
});
|
|
|
|
addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
|
|
week[token] = toInt(input);
|
|
});
|
|
|
|
// HELPERS
|
|
|
|
function parseWeekday(input, locale) {
|
|
if (typeof input !== 'string') {
|
|
return input;
|
|
}
|
|
|
|
if (!isNaN(input)) {
|
|
return parseInt(input, 10);
|
|
}
|
|
|
|
input = locale.weekdaysParse(input);
|
|
if (typeof input === 'number') {
|
|
return input;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function parseIsoWeekday(input, locale) {
|
|
if (typeof input === 'string') {
|
|
return locale.weekdaysParse(input) % 7 || 7;
|
|
}
|
|
return isNaN(input) ? null : input;
|
|
}
|
|
|
|
// LOCALES
|
|
function shiftWeekdays(ws, n) {
|
|
return ws.slice(n, 7).concat(ws.slice(0, n));
|
|
}
|
|
|
|
var defaultLocaleWeekdays =
|
|
'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
|
|
defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
|
|
defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
|
|
defaultWeekdaysRegex = matchWord,
|
|
defaultWeekdaysShortRegex = matchWord,
|
|
defaultWeekdaysMinRegex = matchWord;
|
|
|
|
function localeWeekdays(m, format) {
|
|
var weekdays = isArray(this._weekdays)
|
|
? this._weekdays
|
|
: this._weekdays[
|
|
m && m !== true && this._weekdays.isFormat.test(format)
|
|
? 'format'
|
|
: 'standalone'
|
|
];
|
|
return m === true
|
|
? shiftWeekdays(weekdays, this._week.dow)
|
|
: m
|
|
? weekdays[m.day()]
|
|
: weekdays;
|
|
}
|
|
|
|
function localeWeekdaysShort(m) {
|
|
return m === true
|
|
? shiftWeekdays(this._weekdaysShort, this._week.dow)
|
|
: m
|
|
? this._weekdaysShort[m.day()]
|
|
: this._weekdaysShort;
|
|
}
|
|
|
|
function localeWeekdaysMin(m) {
|
|
return m === true
|
|
? shiftWeekdays(this._weekdaysMin, this._week.dow)
|
|
: m
|
|
? this._weekdaysMin[m.day()]
|
|
: this._weekdaysMin;
|
|
}
|
|
|
|
function handleStrictParse$1(weekdayName, format, strict) {
|
|
var i,
|
|
ii,
|
|
mom,
|
|
llc = weekdayName.toLocaleLowerCase();
|
|
if (!this._weekdaysParse) {
|
|
this._weekdaysParse = [];
|
|
this._shortWeekdaysParse = [];
|
|
this._minWeekdaysParse = [];
|
|
|
|
for (i = 0; i < 7; ++i) {
|
|
mom = createUTC([2000, 1]).day(i);
|
|
this._minWeekdaysParse[i] = this.weekdaysMin(
|
|
mom,
|
|
''
|
|
).toLocaleLowerCase();
|
|
this._shortWeekdaysParse[i] = this.weekdaysShort(
|
|
mom,
|
|
''
|
|
).toLocaleLowerCase();
|
|
this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
|
|
}
|
|
}
|
|
|
|
if (strict) {
|
|
if (format === 'dddd') {
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else if (format === 'ddd') {
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
} else {
|
|
if (format === 'dddd') {
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else if (format === 'ddd') {
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
} else {
|
|
ii = indexOf.call(this._minWeekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._weekdaysParse, llc);
|
|
if (ii !== -1) {
|
|
return ii;
|
|
}
|
|
ii = indexOf.call(this._shortWeekdaysParse, llc);
|
|
return ii !== -1 ? ii : null;
|
|
}
|
|
}
|
|
}
|
|
|
|
function localeWeekdaysParse(weekdayName, format, strict) {
|
|
var i, mom, regex;
|
|
|
|
if (this._weekdaysParseExact) {
|
|
return handleStrictParse$1.call(this, weekdayName, format, strict);
|
|
}
|
|
|
|
if (!this._weekdaysParse) {
|
|
this._weekdaysParse = [];
|
|
this._minWeekdaysParse = [];
|
|
this._shortWeekdaysParse = [];
|
|
this._fullWeekdaysParse = [];
|
|
}
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
// make the regex if we don't have it already
|
|
|
|
mom = createUTC([2000, 1]).day(i);
|
|
if (strict && !this._fullWeekdaysParse[i]) {
|
|
this._fullWeekdaysParse[i] = new RegExp(
|
|
'^' + this.weekdays(mom, '').replace('.', '\\.?') + '$',
|
|
'i'
|
|
);
|
|
this._shortWeekdaysParse[i] = new RegExp(
|
|
'^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$',
|
|
'i'
|
|
);
|
|
this._minWeekdaysParse[i] = new RegExp(
|
|
'^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$',
|
|
'i'
|
|
);
|
|
}
|
|
if (!this._weekdaysParse[i]) {
|
|
regex =
|
|
'^' +
|
|
this.weekdays(mom, '') +
|
|
'|^' +
|
|
this.weekdaysShort(mom, '') +
|
|
'|^' +
|
|
this.weekdaysMin(mom, '');
|
|
this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
|
|
}
|
|
// test the regex
|
|
if (
|
|
strict &&
|
|
format === 'dddd' &&
|
|
this._fullWeekdaysParse[i].test(weekdayName)
|
|
) {
|
|
return i;
|
|
} else if (
|
|
strict &&
|
|
format === 'ddd' &&
|
|
this._shortWeekdaysParse[i].test(weekdayName)
|
|
) {
|
|
return i;
|
|
} else if (
|
|
strict &&
|
|
format === 'dd' &&
|
|
this._minWeekdaysParse[i].test(weekdayName)
|
|
) {
|
|
return i;
|
|
} else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// MOMENTS
|
|
|
|
function getSetDayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
|
|
var day = get(this, 'Day');
|
|
if (input != null) {
|
|
input = parseWeekday(input, this.localeData());
|
|
return this.add(input - day, 'd');
|
|
} else {
|
|
return day;
|
|
}
|
|
}
|
|
|
|
function getSetLocaleDayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
|
|
return input == null ? weekday : this.add(input - weekday, 'd');
|
|
}
|
|
|
|
function getSetISODayOfWeek(input) {
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
|
|
// behaves the same as moment#day except
|
|
// as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
|
|
// as a setter, sunday should belong to the previous week.
|
|
|
|
if (input != null) {
|
|
var weekday = parseIsoWeekday(input, this.localeData());
|
|
return this.day(this.day() % 7 ? weekday : weekday - 7);
|
|
} else {
|
|
return this.day() || 7;
|
|
}
|
|
}
|
|
|
|
function weekdaysRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysStrictRegex;
|
|
} else {
|
|
return this._weekdaysRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
|
this._weekdaysRegex = defaultWeekdaysRegex;
|
|
}
|
|
return this._weekdaysStrictRegex && isStrict
|
|
? this._weekdaysStrictRegex
|
|
: this._weekdaysRegex;
|
|
}
|
|
}
|
|
|
|
function weekdaysShortRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysShortStrictRegex;
|
|
} else {
|
|
return this._weekdaysShortRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, '_weekdaysShortRegex')) {
|
|
this._weekdaysShortRegex = defaultWeekdaysShortRegex;
|
|
}
|
|
return this._weekdaysShortStrictRegex && isStrict
|
|
? this._weekdaysShortStrictRegex
|
|
: this._weekdaysShortRegex;
|
|
}
|
|
}
|
|
|
|
function weekdaysMinRegex(isStrict) {
|
|
if (this._weekdaysParseExact) {
|
|
if (!hasOwnProp(this, '_weekdaysRegex')) {
|
|
computeWeekdaysParse.call(this);
|
|
}
|
|
if (isStrict) {
|
|
return this._weekdaysMinStrictRegex;
|
|
} else {
|
|
return this._weekdaysMinRegex;
|
|
}
|
|
} else {
|
|
if (!hasOwnProp(this, '_weekdaysMinRegex')) {
|
|
this._weekdaysMinRegex = defaultWeekdaysMinRegex;
|
|
}
|
|
return this._weekdaysMinStrictRegex && isStrict
|
|
? this._weekdaysMinStrictRegex
|
|
: this._weekdaysMinRegex;
|
|
}
|
|
}
|
|
|
|
function computeWeekdaysParse() {
|
|
function cmpLenRev(a, b) {
|
|
return b.length - a.length;
|
|
}
|
|
|
|
var minPieces = [],
|
|
shortPieces = [],
|
|
longPieces = [],
|
|
mixedPieces = [],
|
|
i,
|
|
mom,
|
|
minp,
|
|
shortp,
|
|
longp;
|
|
for (i = 0; i < 7; i++) {
|
|
// make the regex if we don't have it already
|
|
mom = createUTC([2000, 1]).day(i);
|
|
minp = regexEscape(this.weekdaysMin(mom, ''));
|
|
shortp = regexEscape(this.weekdaysShort(mom, ''));
|
|
longp = regexEscape(this.weekdays(mom, ''));
|
|
minPieces.push(minp);
|
|
shortPieces.push(shortp);
|
|
longPieces.push(longp);
|
|
mixedPieces.push(minp);
|
|
mixedPieces.push(shortp);
|
|
mixedPieces.push(longp);
|
|
}
|
|
// Sorting makes sure if one weekday (or abbr) is a prefix of another it
|
|
// will match the longer piece.
|
|
minPieces.sort(cmpLenRev);
|
|
shortPieces.sort(cmpLenRev);
|
|
longPieces.sort(cmpLenRev);
|
|
mixedPieces.sort(cmpLenRev);
|
|
|
|
this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
|
|
this._weekdaysShortRegex = this._weekdaysRegex;
|
|
this._weekdaysMinRegex = this._weekdaysRegex;
|
|
|
|
this._weekdaysStrictRegex = new RegExp(
|
|
'^(' + longPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
this._weekdaysShortStrictRegex = new RegExp(
|
|
'^(' + shortPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
this._weekdaysMinStrictRegex = new RegExp(
|
|
'^(' + minPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
function hFormat() {
|
|
return this.hours() % 12 || 12;
|
|
}
|
|
|
|
function kFormat() {
|
|
return this.hours() || 24;
|
|
}
|
|
|
|
addFormatToken('H', ['HH', 2], 0, 'hour');
|
|
addFormatToken('h', ['hh', 2], 0, hFormat);
|
|
addFormatToken('k', ['kk', 2], 0, kFormat);
|
|
|
|
addFormatToken('hmm', 0, 0, function () {
|
|
return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
|
|
});
|
|
|
|
addFormatToken('hmmss', 0, 0, function () {
|
|
return (
|
|
'' +
|
|
hFormat.apply(this) +
|
|
zeroFill(this.minutes(), 2) +
|
|
zeroFill(this.seconds(), 2)
|
|
);
|
|
});
|
|
|
|
addFormatToken('Hmm', 0, 0, function () {
|
|
return '' + this.hours() + zeroFill(this.minutes(), 2);
|
|
});
|
|
|
|
addFormatToken('Hmmss', 0, 0, function () {
|
|
return (
|
|
'' +
|
|
this.hours() +
|
|
zeroFill(this.minutes(), 2) +
|
|
zeroFill(this.seconds(), 2)
|
|
);
|
|
});
|
|
|
|
function meridiem(token, lowercase) {
|
|
addFormatToken(token, 0, 0, function () {
|
|
return this.localeData().meridiem(
|
|
this.hours(),
|
|
this.minutes(),
|
|
lowercase
|
|
);
|
|
});
|
|
}
|
|
|
|
meridiem('a', true);
|
|
meridiem('A', false);
|
|
|
|
// PARSING
|
|
|
|
function matchMeridiem(isStrict, locale) {
|
|
return locale._meridiemParse;
|
|
}
|
|
|
|
addRegexToken('a', matchMeridiem);
|
|
addRegexToken('A', matchMeridiem);
|
|
addRegexToken('H', match1to2, match1to2HasZero);
|
|
addRegexToken('h', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('k', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('HH', match1to2, match2);
|
|
addRegexToken('hh', match1to2, match2);
|
|
addRegexToken('kk', match1to2, match2);
|
|
|
|
addRegexToken('hmm', match3to4);
|
|
addRegexToken('hmmss', match5to6);
|
|
addRegexToken('Hmm', match3to4);
|
|
addRegexToken('Hmmss', match5to6);
|
|
|
|
addParseToken(['H', 'HH'], HOUR);
|
|
addParseToken(['k', 'kk'], function (input, array, config) {
|
|
var kInput = toInt(input);
|
|
array[HOUR] = kInput === 24 ? 0 : kInput;
|
|
});
|
|
addParseToken(['a', 'A'], function (input, array, config) {
|
|
config._isPm = config._locale.isPM(input);
|
|
config._meridiem = input;
|
|
});
|
|
addParseToken(['h', 'hh'], function (input, array, config) {
|
|
array[HOUR] = toInt(input);
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken('hmm', function (input, array, config) {
|
|
var pos = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos));
|
|
array[MINUTE] = toInt(input.substr(pos));
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken('hmmss', function (input, array, config) {
|
|
var pos1 = input.length - 4,
|
|
pos2 = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos1));
|
|
array[MINUTE] = toInt(input.substr(pos1, 2));
|
|
array[SECOND] = toInt(input.substr(pos2));
|
|
getParsingFlags(config).bigHour = true;
|
|
});
|
|
addParseToken('Hmm', function (input, array, config) {
|
|
var pos = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos));
|
|
array[MINUTE] = toInt(input.substr(pos));
|
|
});
|
|
addParseToken('Hmmss', function (input, array, config) {
|
|
var pos1 = input.length - 4,
|
|
pos2 = input.length - 2;
|
|
array[HOUR] = toInt(input.substr(0, pos1));
|
|
array[MINUTE] = toInt(input.substr(pos1, 2));
|
|
array[SECOND] = toInt(input.substr(pos2));
|
|
});
|
|
|
|
// LOCALES
|
|
|
|
function localeIsPM(input) {
|
|
// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
|
|
// Using charAt should be more compatible.
|
|
return (input + '').toLowerCase().charAt(0) === 'p';
|
|
}
|
|
|
|
var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i,
|
|
// Setting the hour should keep the time, because the user explicitly
|
|
// specified which hour they want. So trying to maintain the same hour (in
|
|
// a new timezone) makes sense. Adding/subtracting hours does not follow
|
|
// this rule.
|
|
getSetHour = makeGetSet('Hours', true);
|
|
|
|
function localeMeridiem(hours, minutes, isLower) {
|
|
if (hours > 11) {
|
|
return isLower ? 'pm' : 'PM';
|
|
} else {
|
|
return isLower ? 'am' : 'AM';
|
|
}
|
|
}
|
|
|
|
var baseConfig = {
|
|
calendar: defaultCalendar,
|
|
longDateFormat: defaultLongDateFormat,
|
|
invalidDate: defaultInvalidDate,
|
|
ordinal: defaultOrdinal,
|
|
dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
|
|
relativeTime: defaultRelativeTime,
|
|
|
|
months: defaultLocaleMonths,
|
|
monthsShort: defaultLocaleMonthsShort,
|
|
|
|
week: defaultLocaleWeek,
|
|
|
|
weekdays: defaultLocaleWeekdays,
|
|
weekdaysMin: defaultLocaleWeekdaysMin,
|
|
weekdaysShort: defaultLocaleWeekdaysShort,
|
|
|
|
meridiemParse: defaultLocaleMeridiemParse,
|
|
};
|
|
|
|
// internal storage for locale config files
|
|
var locales = {},
|
|
localeFamilies = {},
|
|
globalLocale;
|
|
|
|
function commonPrefix(arr1, arr2) {
|
|
var i,
|
|
minl = Math.min(arr1.length, arr2.length);
|
|
for (i = 0; i < minl; i += 1) {
|
|
if (arr1[i] !== arr2[i]) {
|
|
return i;
|
|
}
|
|
}
|
|
return minl;
|
|
}
|
|
|
|
function normalizeLocale(key) {
|
|
return key ? key.toLowerCase().replace('_', '-') : key;
|
|
}
|
|
|
|
// pick the locale from the array
|
|
// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
|
|
// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
|
|
function chooseLocale(names) {
|
|
var i = 0,
|
|
j,
|
|
next,
|
|
locale,
|
|
split;
|
|
|
|
while (i < names.length) {
|
|
split = normalizeLocale(names[i]).split('-');
|
|
j = split.length;
|
|
next = normalizeLocale(names[i + 1]);
|
|
next = next ? next.split('-') : null;
|
|
while (j > 0) {
|
|
locale = loadLocale(split.slice(0, j).join('-'));
|
|
if (locale) {
|
|
return locale;
|
|
}
|
|
if (
|
|
next &&
|
|
next.length >= j &&
|
|
commonPrefix(split, next) >= j - 1
|
|
) {
|
|
//the next array item is better than a shallower substring of this one
|
|
break;
|
|
}
|
|
j--;
|
|
}
|
|
i++;
|
|
}
|
|
return globalLocale;
|
|
}
|
|
|
|
function isLocaleNameSane(name) {
|
|
// Prevent names that look like filesystem paths, i.e contain '/' or '\'
|
|
// Ensure name is available and function returns boolean
|
|
return !!(name && name.match('^[^/\\\\]*$'));
|
|
}
|
|
|
|
function loadLocale(name) {
|
|
var oldLocale = null,
|
|
aliasedRequire;
|
|
// TODO: Find a better way to register and load all the locales in Node
|
|
if (
|
|
locales[name] === undefined &&
|
|
'object' !== 'undefined' &&
|
|
module &&
|
|
module.exports &&
|
|
isLocaleNameSane(name)
|
|
) {
|
|
try {
|
|
oldLocale = globalLocale._abbr;
|
|
aliasedRequire = commonjsRequire;
|
|
aliasedRequire('./locale/' + name);
|
|
getSetGlobalLocale(oldLocale);
|
|
} catch (e) {
|
|
// mark as not found to avoid repeating expensive file require call causing high CPU
|
|
// when trying to find en-US, en_US, en-us for every format call
|
|
locales[name] = null; // null means not found
|
|
}
|
|
}
|
|
return locales[name];
|
|
}
|
|
|
|
// This function will load locale and then set the global locale. If
|
|
// no arguments are passed in, it will simply return the current global
|
|
// locale key.
|
|
function getSetGlobalLocale(key, values) {
|
|
var data;
|
|
if (key) {
|
|
if (isUndefined(values)) {
|
|
data = getLocale(key);
|
|
} else {
|
|
data = defineLocale(key, values);
|
|
}
|
|
|
|
if (data) {
|
|
// moment.duration._locale = moment._locale = data;
|
|
globalLocale = data;
|
|
} else {
|
|
if (typeof console !== 'undefined' && console.warn) {
|
|
//warn user if arguments are passed but the locale could not be set
|
|
console.warn(
|
|
'Locale ' + key + ' not found. Did you forget to load it?'
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return globalLocale._abbr;
|
|
}
|
|
|
|
function defineLocale(name, config) {
|
|
if (config !== null) {
|
|
var locale,
|
|
parentConfig = baseConfig;
|
|
config.abbr = name;
|
|
if (locales[name] != null) {
|
|
deprecateSimple(
|
|
'defineLocaleOverride',
|
|
'use moment.updateLocale(localeName, config) to change ' +
|
|
'an existing locale. moment.defineLocale(localeName, ' +
|
|
'config) should only be used for creating a new locale ' +
|
|
'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'
|
|
);
|
|
parentConfig = locales[name]._config;
|
|
} else if (config.parentLocale != null) {
|
|
if (locales[config.parentLocale] != null) {
|
|
parentConfig = locales[config.parentLocale]._config;
|
|
} else {
|
|
locale = loadLocale(config.parentLocale);
|
|
if (locale != null) {
|
|
parentConfig = locale._config;
|
|
} else {
|
|
if (!localeFamilies[config.parentLocale]) {
|
|
localeFamilies[config.parentLocale] = [];
|
|
}
|
|
localeFamilies[config.parentLocale].push({
|
|
name: name,
|
|
config: config,
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
locales[name] = new Locale(mergeConfigs(parentConfig, config));
|
|
|
|
if (localeFamilies[name]) {
|
|
localeFamilies[name].forEach(function (x) {
|
|
defineLocale(x.name, x.config);
|
|
});
|
|
}
|
|
|
|
// backwards compat for now: also set the locale
|
|
// make sure we set the locale AFTER all child locales have been
|
|
// created, so we won't end up with the child locale set.
|
|
getSetGlobalLocale(name);
|
|
|
|
return locales[name];
|
|
} else {
|
|
// useful for testing
|
|
delete locales[name];
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function updateLocale(name, config) {
|
|
if (config != null) {
|
|
var locale,
|
|
tmpLocale,
|
|
parentConfig = baseConfig;
|
|
|
|
if (locales[name] != null && locales[name].parentLocale != null) {
|
|
// Update existing child locale in-place to avoid memory-leaks
|
|
locales[name].set(mergeConfigs(locales[name]._config, config));
|
|
} else {
|
|
// MERGE
|
|
tmpLocale = loadLocale(name);
|
|
if (tmpLocale != null) {
|
|
parentConfig = tmpLocale._config;
|
|
}
|
|
config = mergeConfigs(parentConfig, config);
|
|
if (tmpLocale == null) {
|
|
// updateLocale is called for creating a new locale
|
|
// Set abbr so it will have a name (getters return
|
|
// undefined otherwise).
|
|
config.abbr = name;
|
|
}
|
|
locale = new Locale(config);
|
|
locale.parentLocale = locales[name];
|
|
locales[name] = locale;
|
|
}
|
|
|
|
// backwards compat for now: also set the locale
|
|
getSetGlobalLocale(name);
|
|
} else {
|
|
// pass null for config to unupdate, useful for tests
|
|
if (locales[name] != null) {
|
|
if (locales[name].parentLocale != null) {
|
|
locales[name] = locales[name].parentLocale;
|
|
if (name === getSetGlobalLocale()) {
|
|
getSetGlobalLocale(name);
|
|
}
|
|
} else if (locales[name] != null) {
|
|
delete locales[name];
|
|
}
|
|
}
|
|
}
|
|
return locales[name];
|
|
}
|
|
|
|
// returns locale data
|
|
function getLocale(key) {
|
|
var locale;
|
|
|
|
if (key && key._locale && key._locale._abbr) {
|
|
key = key._locale._abbr;
|
|
}
|
|
|
|
if (!key) {
|
|
return globalLocale;
|
|
}
|
|
|
|
if (!isArray(key)) {
|
|
//short-circuit everything else
|
|
locale = loadLocale(key);
|
|
if (locale) {
|
|
return locale;
|
|
}
|
|
key = [key];
|
|
}
|
|
|
|
return chooseLocale(key);
|
|
}
|
|
|
|
function listLocales() {
|
|
return keys(locales);
|
|
}
|
|
|
|
function checkOverflow(m) {
|
|
var overflow,
|
|
a = m._a;
|
|
|
|
if (a && getParsingFlags(m).overflow === -2) {
|
|
overflow =
|
|
a[MONTH] < 0 || a[MONTH] > 11
|
|
? MONTH
|
|
: a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
|
|
? DATE
|
|
: a[HOUR] < 0 ||
|
|
a[HOUR] > 24 ||
|
|
(a[HOUR] === 24 &&
|
|
(a[MINUTE] !== 0 ||
|
|
a[SECOND] !== 0 ||
|
|
a[MILLISECOND] !== 0))
|
|
? HOUR
|
|
: a[MINUTE] < 0 || a[MINUTE] > 59
|
|
? MINUTE
|
|
: a[SECOND] < 0 || a[SECOND] > 59
|
|
? SECOND
|
|
: a[MILLISECOND] < 0 || a[MILLISECOND] > 999
|
|
? MILLISECOND
|
|
: -1;
|
|
|
|
if (
|
|
getParsingFlags(m)._overflowDayOfYear &&
|
|
(overflow < YEAR || overflow > DATE)
|
|
) {
|
|
overflow = DATE;
|
|
}
|
|
if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
|
|
overflow = WEEK;
|
|
}
|
|
if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
|
|
overflow = WEEKDAY;
|
|
}
|
|
|
|
getParsingFlags(m).overflow = overflow;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
// iso 8601 regex
|
|
// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
|
|
var extendedIsoRegex =
|
|
/^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
|
basicIsoRegex =
|
|
/^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/,
|
|
tzRegex = /Z|[+-]\d\d(?::?\d\d)?/,
|
|
isoDates = [
|
|
['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
|
|
['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
|
|
['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
|
|
['GGGG-[W]WW', /\d{4}-W\d\d/, false],
|
|
['YYYY-DDD', /\d{4}-\d{3}/],
|
|
['YYYY-MM', /\d{4}-\d\d/, false],
|
|
['YYYYYYMMDD', /[+-]\d{10}/],
|
|
['YYYYMMDD', /\d{8}/],
|
|
['GGGG[W]WWE', /\d{4}W\d{3}/],
|
|
['GGGG[W]WW', /\d{4}W\d{2}/, false],
|
|
['YYYYDDD', /\d{7}/],
|
|
['YYYYMM', /\d{6}/, false],
|
|
['YYYY', /\d{4}/, false],
|
|
],
|
|
// iso time formats and regexes
|
|
isoTimes = [
|
|
['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
|
|
['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
|
|
['HH:mm:ss', /\d\d:\d\d:\d\d/],
|
|
['HH:mm', /\d\d:\d\d/],
|
|
['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
|
|
['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
|
|
['HHmmss', /\d\d\d\d\d\d/],
|
|
['HHmm', /\d\d\d\d/],
|
|
['HH', /\d\d/],
|
|
],
|
|
aspNetJsonRegex = /^\/?Date\((-?\d+)/i,
|
|
// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
|
|
rfc2822 =
|
|
/^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/,
|
|
obsOffsets = {
|
|
UT: 0,
|
|
GMT: 0,
|
|
EDT: -4 * 60,
|
|
EST: -5 * 60,
|
|
CDT: -5 * 60,
|
|
CST: -6 * 60,
|
|
MDT: -6 * 60,
|
|
MST: -7 * 60,
|
|
PDT: -7 * 60,
|
|
PST: -8 * 60,
|
|
};
|
|
|
|
// date from iso format
|
|
function configFromISO(config) {
|
|
var i,
|
|
l,
|
|
string = config._i,
|
|
match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
|
|
allowTime,
|
|
dateFormat,
|
|
timeFormat,
|
|
tzFormat,
|
|
isoDatesLen = isoDates.length,
|
|
isoTimesLen = isoTimes.length;
|
|
|
|
if (match) {
|
|
getParsingFlags(config).iso = true;
|
|
for (i = 0, l = isoDatesLen; i < l; i++) {
|
|
if (isoDates[i][1].exec(match[1])) {
|
|
dateFormat = isoDates[i][0];
|
|
allowTime = isoDates[i][2] !== false;
|
|
break;
|
|
}
|
|
}
|
|
if (dateFormat == null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
if (match[3]) {
|
|
for (i = 0, l = isoTimesLen; i < l; i++) {
|
|
if (isoTimes[i][1].exec(match[3])) {
|
|
// match[2] should be 'T' or space
|
|
timeFormat = (match[2] || ' ') + isoTimes[i][0];
|
|
break;
|
|
}
|
|
}
|
|
if (timeFormat == null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
}
|
|
if (!allowTime && timeFormat != null) {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
if (match[4]) {
|
|
if (tzRegex.exec(match[4])) {
|
|
tzFormat = 'Z';
|
|
} else {
|
|
config._isValid = false;
|
|
return;
|
|
}
|
|
}
|
|
config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
|
|
configFromStringAndFormat(config);
|
|
} else {
|
|
config._isValid = false;
|
|
}
|
|
}
|
|
|
|
function extractFromRFC2822Strings(
|
|
yearStr,
|
|
monthStr,
|
|
dayStr,
|
|
hourStr,
|
|
minuteStr,
|
|
secondStr
|
|
) {
|
|
var result = [
|
|
untruncateYear(yearStr),
|
|
defaultLocaleMonthsShort.indexOf(monthStr),
|
|
parseInt(dayStr, 10),
|
|
parseInt(hourStr, 10),
|
|
parseInt(minuteStr, 10),
|
|
];
|
|
|
|
if (secondStr) {
|
|
result.push(parseInt(secondStr, 10));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
function untruncateYear(yearStr) {
|
|
var year = parseInt(yearStr, 10);
|
|
if (year <= 49) {
|
|
return 2000 + year;
|
|
} else if (year <= 999) {
|
|
return 1900 + year;
|
|
}
|
|
return year;
|
|
}
|
|
|
|
function preprocessRFC2822(s) {
|
|
// Remove comments and folding whitespace and replace multiple-spaces with a single space
|
|
return s
|
|
.replace(/\([^()]*\)|[\n\t]/g, ' ')
|
|
.replace(/(\s\s+)/g, ' ')
|
|
.replace(/^\s\s*/, '')
|
|
.replace(/\s\s*$/, '');
|
|
}
|
|
|
|
function checkWeekday(weekdayStr, parsedInput, config) {
|
|
if (weekdayStr) {
|
|
// TODO: Replace the vanilla JS Date object with an independent day-of-week check.
|
|
var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
|
|
weekdayActual = new Date(
|
|
parsedInput[0],
|
|
parsedInput[1],
|
|
parsedInput[2]
|
|
).getDay();
|
|
if (weekdayProvided !== weekdayActual) {
|
|
getParsingFlags(config).weekdayMismatch = true;
|
|
config._isValid = false;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function calculateOffset(obsOffset, militaryOffset, numOffset) {
|
|
if (obsOffset) {
|
|
return obsOffsets[obsOffset];
|
|
} else if (militaryOffset) {
|
|
// the only allowed military tz is Z
|
|
return 0;
|
|
} else {
|
|
var hm = parseInt(numOffset, 10),
|
|
m = hm % 100,
|
|
h = (hm - m) / 100;
|
|
return h * 60 + m;
|
|
}
|
|
}
|
|
|
|
// date and time from ref 2822 format
|
|
function configFromRFC2822(config) {
|
|
var match = rfc2822.exec(preprocessRFC2822(config._i)),
|
|
parsedArray;
|
|
if (match) {
|
|
parsedArray = extractFromRFC2822Strings(
|
|
match[4],
|
|
match[3],
|
|
match[2],
|
|
match[5],
|
|
match[6],
|
|
match[7]
|
|
);
|
|
if (!checkWeekday(match[1], parsedArray, config)) {
|
|
return;
|
|
}
|
|
|
|
config._a = parsedArray;
|
|
config._tzm = calculateOffset(match[8], match[9], match[10]);
|
|
|
|
config._d = createUTCDate.apply(null, config._a);
|
|
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
|
|
|
|
getParsingFlags(config).rfc2822 = true;
|
|
} else {
|
|
config._isValid = false;
|
|
}
|
|
}
|
|
|
|
// date from 1) ASP.NET, 2) ISO, 3) RFC 2822 formats, or 4) optional fallback if parsing isn't strict
|
|
function configFromString(config) {
|
|
var matched = aspNetJsonRegex.exec(config._i);
|
|
if (matched !== null) {
|
|
config._d = new Date(+matched[1]);
|
|
return;
|
|
}
|
|
|
|
configFromISO(config);
|
|
if (config._isValid === false) {
|
|
delete config._isValid;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
configFromRFC2822(config);
|
|
if (config._isValid === false) {
|
|
delete config._isValid;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (config._strict) {
|
|
config._isValid = false;
|
|
} else {
|
|
// Final attempt, use Input Fallback
|
|
hooks.createFromInputFallback(config);
|
|
}
|
|
}
|
|
|
|
hooks.createFromInputFallback = deprecate(
|
|
'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
|
|
'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
|
|
'discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.',
|
|
function (config) {
|
|
config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
|
|
}
|
|
);
|
|
|
|
// Pick the first defined of two or three arguments.
|
|
function defaults(a, b, c) {
|
|
if (a != null) {
|
|
return a;
|
|
}
|
|
if (b != null) {
|
|
return b;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
function currentDateArray(config) {
|
|
// hooks is actually the exported moment object
|
|
var nowValue = new Date(hooks.now());
|
|
if (config._useUTC) {
|
|
return [
|
|
nowValue.getUTCFullYear(),
|
|
nowValue.getUTCMonth(),
|
|
nowValue.getUTCDate(),
|
|
];
|
|
}
|
|
return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
|
|
}
|
|
|
|
// convert an array to a date.
|
|
// the array should mirror the parameters below
|
|
// note: all values past the year are optional and will default to the lowest possible value.
|
|
// [year, month, day , hour, minute, second, millisecond]
|
|
function configFromArray(config) {
|
|
var i,
|
|
date,
|
|
input = [],
|
|
currentDate,
|
|
expectedWeekday,
|
|
yearToUse;
|
|
|
|
if (config._d) {
|
|
return;
|
|
}
|
|
|
|
currentDate = currentDateArray(config);
|
|
|
|
//compute day of the year from weeks and weekdays
|
|
if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
|
|
dayOfYearFromWeekInfo(config);
|
|
}
|
|
|
|
//if the day of the year is set, figure out what it is
|
|
if (config._dayOfYear != null) {
|
|
yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
|
|
|
|
if (
|
|
config._dayOfYear > daysInYear(yearToUse) ||
|
|
config._dayOfYear === 0
|
|
) {
|
|
getParsingFlags(config)._overflowDayOfYear = true;
|
|
}
|
|
|
|
date = createUTCDate(yearToUse, 0, config._dayOfYear);
|
|
config._a[MONTH] = date.getUTCMonth();
|
|
config._a[DATE] = date.getUTCDate();
|
|
}
|
|
|
|
// Default to current date.
|
|
// * if no year, month, day of month are given, default to today
|
|
// * if day of month is given, default month and year
|
|
// * if month is given, default only year
|
|
// * if year is given, don't default anything
|
|
for (i = 0; i < 3 && config._a[i] == null; ++i) {
|
|
config._a[i] = input[i] = currentDate[i];
|
|
}
|
|
|
|
// Zero out whatever was not defaulted, including time
|
|
for (; i < 7; i++) {
|
|
config._a[i] = input[i] =
|
|
config._a[i] == null ? (i === 2 ? 1 : 0) : config._a[i];
|
|
}
|
|
|
|
// Check for 24:00:00.000
|
|
if (
|
|
config._a[HOUR] === 24 &&
|
|
config._a[MINUTE] === 0 &&
|
|
config._a[SECOND] === 0 &&
|
|
config._a[MILLISECOND] === 0
|
|
) {
|
|
config._nextDay = true;
|
|
config._a[HOUR] = 0;
|
|
}
|
|
|
|
config._d = (config._useUTC ? createUTCDate : createDate).apply(
|
|
null,
|
|
input
|
|
);
|
|
expectedWeekday = config._useUTC
|
|
? config._d.getUTCDay()
|
|
: config._d.getDay();
|
|
|
|
// Apply timezone offset from input. The actual utcOffset can be changed
|
|
// with parseZone.
|
|
if (config._tzm != null) {
|
|
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
|
|
}
|
|
|
|
if (config._nextDay) {
|
|
config._a[HOUR] = 24;
|
|
}
|
|
|
|
// check for mismatching day of week
|
|
if (
|
|
config._w &&
|
|
typeof config._w.d !== 'undefined' &&
|
|
config._w.d !== expectedWeekday
|
|
) {
|
|
getParsingFlags(config).weekdayMismatch = true;
|
|
}
|
|
}
|
|
|
|
function dayOfYearFromWeekInfo(config) {
|
|
var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek;
|
|
|
|
w = config._w;
|
|
if (w.GG != null || w.W != null || w.E != null) {
|
|
dow = 1;
|
|
doy = 4;
|
|
|
|
// TODO: We need to take the current isoWeekYear, but that depends on
|
|
// how we interpret now (local, utc, fixed offset). So create
|
|
// a now version of current config (take local/utc/offset flags, and
|
|
// create now).
|
|
weekYear = defaults(
|
|
w.GG,
|
|
config._a[YEAR],
|
|
weekOfYear(createLocal(), 1, 4).year
|
|
);
|
|
week = defaults(w.W, 1);
|
|
weekday = defaults(w.E, 1);
|
|
if (weekday < 1 || weekday > 7) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else {
|
|
dow = config._locale._week.dow;
|
|
doy = config._locale._week.doy;
|
|
|
|
curWeek = weekOfYear(createLocal(), dow, doy);
|
|
|
|
weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
|
|
|
|
// Default to current week.
|
|
week = defaults(w.w, curWeek.week);
|
|
|
|
if (w.d != null) {
|
|
// weekday -- low day numbers are considered next week
|
|
weekday = w.d;
|
|
if (weekday < 0 || weekday > 6) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else if (w.e != null) {
|
|
// local weekday -- counting starts from beginning of week
|
|
weekday = w.e + dow;
|
|
if (w.e < 0 || w.e > 6) {
|
|
weekdayOverflow = true;
|
|
}
|
|
} else {
|
|
// default to beginning of week
|
|
weekday = dow;
|
|
}
|
|
}
|
|
if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
|
|
getParsingFlags(config)._overflowWeeks = true;
|
|
} else if (weekdayOverflow != null) {
|
|
getParsingFlags(config)._overflowWeekday = true;
|
|
} else {
|
|
temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
|
|
config._a[YEAR] = temp.year;
|
|
config._dayOfYear = temp.dayOfYear;
|
|
}
|
|
}
|
|
|
|
// constant that refers to the ISO standard
|
|
hooks.ISO_8601 = function () {};
|
|
|
|
// constant that refers to the RFC 2822 form
|
|
hooks.RFC_2822 = function () {};
|
|
|
|
// date from string and format string
|
|
function configFromStringAndFormat(config) {
|
|
// TODO: Move this to another part of the creation flow to prevent circular deps
|
|
if (config._f === hooks.ISO_8601) {
|
|
configFromISO(config);
|
|
return;
|
|
}
|
|
if (config._f === hooks.RFC_2822) {
|
|
configFromRFC2822(config);
|
|
return;
|
|
}
|
|
config._a = [];
|
|
getParsingFlags(config).empty = true;
|
|
|
|
// This array is used to make a Date, either with `new Date` or `Date.UTC`
|
|
var string = '' + config._i,
|
|
i,
|
|
parsedInput,
|
|
tokens,
|
|
token,
|
|
skipped,
|
|
stringLength = string.length,
|
|
totalParsedInputLength = 0,
|
|
era,
|
|
tokenLen;
|
|
|
|
tokens =
|
|
expandFormat(config._f, config._locale).match(formattingTokens) || [];
|
|
tokenLen = tokens.length;
|
|
for (i = 0; i < tokenLen; i++) {
|
|
token = tokens[i];
|
|
parsedInput = (string.match(getParseRegexForToken(token, config)) ||
|
|
[])[0];
|
|
if (parsedInput) {
|
|
skipped = string.substr(0, string.indexOf(parsedInput));
|
|
if (skipped.length > 0) {
|
|
getParsingFlags(config).unusedInput.push(skipped);
|
|
}
|
|
string = string.slice(
|
|
string.indexOf(parsedInput) + parsedInput.length
|
|
);
|
|
totalParsedInputLength += parsedInput.length;
|
|
}
|
|
// don't parse if it's not a known token
|
|
if (formatTokenFunctions[token]) {
|
|
if (parsedInput) {
|
|
getParsingFlags(config).empty = false;
|
|
} else {
|
|
getParsingFlags(config).unusedTokens.push(token);
|
|
}
|
|
addTimeToArrayFromToken(token, parsedInput, config);
|
|
} else if (config._strict && !parsedInput) {
|
|
getParsingFlags(config).unusedTokens.push(token);
|
|
}
|
|
}
|
|
|
|
// add remaining unparsed input length to the string
|
|
getParsingFlags(config).charsLeftOver =
|
|
stringLength - totalParsedInputLength;
|
|
if (string.length > 0) {
|
|
getParsingFlags(config).unusedInput.push(string);
|
|
}
|
|
|
|
// clear _12h flag if hour is <= 12
|
|
if (
|
|
config._a[HOUR] <= 12 &&
|
|
getParsingFlags(config).bigHour === true &&
|
|
config._a[HOUR] > 0
|
|
) {
|
|
getParsingFlags(config).bigHour = undefined;
|
|
}
|
|
|
|
getParsingFlags(config).parsedDateParts = config._a.slice(0);
|
|
getParsingFlags(config).meridiem = config._meridiem;
|
|
// handle meridiem
|
|
config._a[HOUR] = meridiemFixWrap(
|
|
config._locale,
|
|
config._a[HOUR],
|
|
config._meridiem
|
|
);
|
|
|
|
// handle era
|
|
era = getParsingFlags(config).era;
|
|
if (era !== null) {
|
|
config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]);
|
|
}
|
|
|
|
configFromArray(config);
|
|
checkOverflow(config);
|
|
}
|
|
|
|
function meridiemFixWrap(locale, hour, meridiem) {
|
|
var isPm;
|
|
|
|
if (meridiem == null) {
|
|
// nothing to do
|
|
return hour;
|
|
}
|
|
if (locale.meridiemHour != null) {
|
|
return locale.meridiemHour(hour, meridiem);
|
|
} else if (locale.isPM != null) {
|
|
// Fallback
|
|
isPm = locale.isPM(meridiem);
|
|
if (isPm && hour < 12) {
|
|
hour += 12;
|
|
}
|
|
if (!isPm && hour === 12) {
|
|
hour = 0;
|
|
}
|
|
return hour;
|
|
} else {
|
|
// this is not supposed to happen
|
|
return hour;
|
|
}
|
|
}
|
|
|
|
// date from string and array of format strings
|
|
function configFromStringAndArray(config) {
|
|
var tempConfig,
|
|
bestMoment,
|
|
scoreToBeat,
|
|
i,
|
|
currentScore,
|
|
validFormatFound,
|
|
bestFormatIsValid = false,
|
|
configfLen = config._f.length;
|
|
|
|
if (configfLen === 0) {
|
|
getParsingFlags(config).invalidFormat = true;
|
|
config._d = new Date(NaN);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < configfLen; i++) {
|
|
currentScore = 0;
|
|
validFormatFound = false;
|
|
tempConfig = copyConfig({}, config);
|
|
if (config._useUTC != null) {
|
|
tempConfig._useUTC = config._useUTC;
|
|
}
|
|
tempConfig._f = config._f[i];
|
|
configFromStringAndFormat(tempConfig);
|
|
|
|
if (isValid(tempConfig)) {
|
|
validFormatFound = true;
|
|
}
|
|
|
|
// if there is any input that was not parsed add a penalty for that format
|
|
currentScore += getParsingFlags(tempConfig).charsLeftOver;
|
|
|
|
//or tokens
|
|
currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
|
|
|
|
getParsingFlags(tempConfig).score = currentScore;
|
|
|
|
if (!bestFormatIsValid) {
|
|
if (
|
|
scoreToBeat == null ||
|
|
currentScore < scoreToBeat ||
|
|
validFormatFound
|
|
) {
|
|
scoreToBeat = currentScore;
|
|
bestMoment = tempConfig;
|
|
if (validFormatFound) {
|
|
bestFormatIsValid = true;
|
|
}
|
|
}
|
|
} else {
|
|
if (currentScore < scoreToBeat) {
|
|
scoreToBeat = currentScore;
|
|
bestMoment = tempConfig;
|
|
}
|
|
}
|
|
}
|
|
|
|
extend(config, bestMoment || tempConfig);
|
|
}
|
|
|
|
function configFromObject(config) {
|
|
if (config._d) {
|
|
return;
|
|
}
|
|
|
|
var i = normalizeObjectUnits(config._i),
|
|
dayOrDate = i.day === undefined ? i.date : i.day;
|
|
config._a = map(
|
|
[i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond],
|
|
function (obj) {
|
|
return obj && parseInt(obj, 10);
|
|
}
|
|
);
|
|
|
|
configFromArray(config);
|
|
}
|
|
|
|
function createFromConfig(config) {
|
|
var res = new Moment(checkOverflow(prepareConfig(config)));
|
|
if (res._nextDay) {
|
|
// Adding is smart enough around DST
|
|
res.add(1, 'd');
|
|
res._nextDay = undefined;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
function prepareConfig(config) {
|
|
var input = config._i,
|
|
format = config._f;
|
|
|
|
config._locale = config._locale || getLocale(config._l);
|
|
|
|
if (input === null || (format === undefined && input === '')) {
|
|
return createInvalid({ nullInput: true });
|
|
}
|
|
|
|
if (typeof input === 'string') {
|
|
config._i = input = config._locale.preparse(input);
|
|
}
|
|
|
|
if (isMoment(input)) {
|
|
return new Moment(checkOverflow(input));
|
|
} else if (isDate(input)) {
|
|
config._d = input;
|
|
} else if (isArray(format)) {
|
|
configFromStringAndArray(config);
|
|
} else if (format) {
|
|
configFromStringAndFormat(config);
|
|
} else {
|
|
configFromInput(config);
|
|
}
|
|
|
|
if (!isValid(config)) {
|
|
config._d = null;
|
|
}
|
|
|
|
return config;
|
|
}
|
|
|
|
function configFromInput(config) {
|
|
var input = config._i;
|
|
if (isUndefined(input)) {
|
|
config._d = new Date(hooks.now());
|
|
} else if (isDate(input)) {
|
|
config._d = new Date(input.valueOf());
|
|
} else if (typeof input === 'string') {
|
|
configFromString(config);
|
|
} else if (isArray(input)) {
|
|
config._a = map(input.slice(0), function (obj) {
|
|
return parseInt(obj, 10);
|
|
});
|
|
configFromArray(config);
|
|
} else if (isObject(input)) {
|
|
configFromObject(config);
|
|
} else if (isNumber(input)) {
|
|
// from milliseconds
|
|
config._d = new Date(input);
|
|
} else {
|
|
hooks.createFromInputFallback(config);
|
|
}
|
|
}
|
|
|
|
function createLocalOrUTC(input, format, locale, strict, isUTC) {
|
|
var c = {};
|
|
|
|
if (format === true || format === false) {
|
|
strict = format;
|
|
format = undefined;
|
|
}
|
|
|
|
if (locale === true || locale === false) {
|
|
strict = locale;
|
|
locale = undefined;
|
|
}
|
|
|
|
if (
|
|
(isObject(input) && isObjectEmpty(input)) ||
|
|
(isArray(input) && input.length === 0)
|
|
) {
|
|
input = undefined;
|
|
}
|
|
// object construction must be done this way.
|
|
// https://github.com/moment/moment/issues/1423
|
|
c._isAMomentObject = true;
|
|
c._useUTC = c._isUTC = isUTC;
|
|
c._l = locale;
|
|
c._i = input;
|
|
c._f = format;
|
|
c._strict = strict;
|
|
|
|
return createFromConfig(c);
|
|
}
|
|
|
|
function createLocal(input, format, locale, strict) {
|
|
return createLocalOrUTC(input, format, locale, strict, false);
|
|
}
|
|
|
|
var prototypeMin = deprecate(
|
|
'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
|
|
function () {
|
|
var other = createLocal.apply(null, arguments);
|
|
if (this.isValid() && other.isValid()) {
|
|
return other < this ? this : other;
|
|
} else {
|
|
return createInvalid();
|
|
}
|
|
}
|
|
),
|
|
prototypeMax = deprecate(
|
|
'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
|
|
function () {
|
|
var other = createLocal.apply(null, arguments);
|
|
if (this.isValid() && other.isValid()) {
|
|
return other > this ? this : other;
|
|
} else {
|
|
return createInvalid();
|
|
}
|
|
}
|
|
);
|
|
|
|
// Pick a moment m from moments so that m[fn](other) is true for all
|
|
// other. This relies on the function fn to be transitive.
|
|
//
|
|
// moments should either be an array of moment objects or an array, whose
|
|
// first element is an array of moment objects.
|
|
function pickBy(fn, moments) {
|
|
var res, i;
|
|
if (moments.length === 1 && isArray(moments[0])) {
|
|
moments = moments[0];
|
|
}
|
|
if (!moments.length) {
|
|
return createLocal();
|
|
}
|
|
res = moments[0];
|
|
for (i = 1; i < moments.length; ++i) {
|
|
if (!moments[i].isValid() || moments[i][fn](res)) {
|
|
res = moments[i];
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// TODO: Use [].sort instead?
|
|
function min() {
|
|
var args = [].slice.call(arguments, 0);
|
|
|
|
return pickBy('isBefore', args);
|
|
}
|
|
|
|
function max() {
|
|
var args = [].slice.call(arguments, 0);
|
|
|
|
return pickBy('isAfter', args);
|
|
}
|
|
|
|
var now = function () {
|
|
return Date.now ? Date.now() : +new Date();
|
|
};
|
|
|
|
var ordering = [
|
|
'year',
|
|
'quarter',
|
|
'month',
|
|
'week',
|
|
'day',
|
|
'hour',
|
|
'minute',
|
|
'second',
|
|
'millisecond',
|
|
];
|
|
|
|
function isDurationValid(m) {
|
|
var key,
|
|
unitHasDecimal = false,
|
|
i,
|
|
orderLen = ordering.length;
|
|
for (key in m) {
|
|
if (
|
|
hasOwnProp(m, key) &&
|
|
!(
|
|
indexOf.call(ordering, key) !== -1 &&
|
|
(m[key] == null || !isNaN(m[key]))
|
|
)
|
|
) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < orderLen; ++i) {
|
|
if (m[ordering[i]]) {
|
|
if (unitHasDecimal) {
|
|
return false; // only allow non-integers for smallest unit
|
|
}
|
|
if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
|
|
unitHasDecimal = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function isValid$1() {
|
|
return this._isValid;
|
|
}
|
|
|
|
function createInvalid$1() {
|
|
return createDuration(NaN);
|
|
}
|
|
|
|
function Duration(duration) {
|
|
var normalizedInput = normalizeObjectUnits(duration),
|
|
years = normalizedInput.year || 0,
|
|
quarters = normalizedInput.quarter || 0,
|
|
months = normalizedInput.month || 0,
|
|
weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
|
|
days = normalizedInput.day || 0,
|
|
hours = normalizedInput.hour || 0,
|
|
minutes = normalizedInput.minute || 0,
|
|
seconds = normalizedInput.second || 0,
|
|
milliseconds = normalizedInput.millisecond || 0;
|
|
|
|
this._isValid = isDurationValid(normalizedInput);
|
|
|
|
// representation for dateAddRemove
|
|
this._milliseconds =
|
|
+milliseconds +
|
|
seconds * 1e3 + // 1000
|
|
minutes * 6e4 + // 1000 * 60
|
|
hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
|
|
// Because of dateAddRemove treats 24 hours as different from a
|
|
// day when working around DST, we need to store them separately
|
|
this._days = +days + weeks * 7;
|
|
// It is impossible to translate months into days without knowing
|
|
// which months you are are talking about, so we have to store
|
|
// it separately.
|
|
this._months = +months + quarters * 3 + years * 12;
|
|
|
|
this._data = {};
|
|
|
|
this._locale = getLocale();
|
|
|
|
this._bubble();
|
|
}
|
|
|
|
function isDuration(obj) {
|
|
return obj instanceof Duration;
|
|
}
|
|
|
|
function absRound(number) {
|
|
if (number < 0) {
|
|
return Math.round(-1 * number) * -1;
|
|
} else {
|
|
return Math.round(number);
|
|
}
|
|
}
|
|
|
|
// compare two arrays, return the number of differences
|
|
function compareArrays(array1, array2, dontConvert) {
|
|
var len = Math.min(array1.length, array2.length),
|
|
lengthDiff = Math.abs(array1.length - array2.length),
|
|
diffs = 0,
|
|
i;
|
|
for (i = 0; i < len; i++) {
|
|
if (
|
|
(dontConvert && array1[i] !== array2[i]) ||
|
|
(!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
|
|
) {
|
|
diffs++;
|
|
}
|
|
}
|
|
return diffs + lengthDiff;
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
function offset(token, separator) {
|
|
addFormatToken(token, 0, 0, function () {
|
|
var offset = this.utcOffset(),
|
|
sign = '+';
|
|
if (offset < 0) {
|
|
offset = -offset;
|
|
sign = '-';
|
|
}
|
|
return (
|
|
sign +
|
|
zeroFill(~~(offset / 60), 2) +
|
|
separator +
|
|
zeroFill(~~offset % 60, 2)
|
|
);
|
|
});
|
|
}
|
|
|
|
offset('Z', ':');
|
|
offset('ZZ', '');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('Z', matchShortOffset);
|
|
addRegexToken('ZZ', matchShortOffset);
|
|
addParseToken(['Z', 'ZZ'], function (input, array, config) {
|
|
config._useUTC = true;
|
|
config._tzm = offsetFromString(matchShortOffset, input);
|
|
});
|
|
|
|
// HELPERS
|
|
|
|
// timezone chunker
|
|
// '+10:00' > ['10', '00']
|
|
// '-1530' > ['-15', '30']
|
|
var chunkOffset = /([\+\-]|\d\d)/gi;
|
|
|
|
function offsetFromString(matcher, string) {
|
|
var matches = (string || '').match(matcher),
|
|
chunk,
|
|
parts,
|
|
minutes;
|
|
|
|
if (matches === null) {
|
|
return null;
|
|
}
|
|
|
|
chunk = matches[matches.length - 1] || [];
|
|
parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
|
|
minutes = +(parts[1] * 60) + toInt(parts[2]);
|
|
|
|
return minutes === 0 ? 0 : parts[0] === '+' ? minutes : -minutes;
|
|
}
|
|
|
|
// Return a moment from input, that is local/utc/zone equivalent to model.
|
|
function cloneWithOffset(input, model) {
|
|
var res, diff;
|
|
if (model._isUTC) {
|
|
res = model.clone();
|
|
diff =
|
|
(isMoment(input) || isDate(input)
|
|
? input.valueOf()
|
|
: createLocal(input).valueOf()) - res.valueOf();
|
|
// Use low-level api, because this fn is low-level api.
|
|
res._d.setTime(res._d.valueOf() + diff);
|
|
hooks.updateOffset(res, false);
|
|
return res;
|
|
} else {
|
|
return createLocal(input).local();
|
|
}
|
|
}
|
|
|
|
function getDateOffset(m) {
|
|
// On Firefox.24 Date#getTimezoneOffset returns a floating point.
|
|
// https://github.com/moment/moment/pull/1871
|
|
return -Math.round(m._d.getTimezoneOffset());
|
|
}
|
|
|
|
// HOOKS
|
|
|
|
// This function will be called whenever a moment is mutated.
|
|
// It is intended to keep the offset in sync with the timezone.
|
|
hooks.updateOffset = function () {};
|
|
|
|
// MOMENTS
|
|
|
|
// keepLocalTime = true means only change the timezone, without
|
|
// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
|
|
// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
|
|
// +0200, so we adjust the time as needed, to be valid.
|
|
//
|
|
// Keeping the time actually adds/subtracts (one hour)
|
|
// from the actual represented time. That is why we call updateOffset
|
|
// a second time. In case it wants us to change the offset again
|
|
// _changeInProgress == true case, then we have to adjust, because
|
|
// there is no such time in the given timezone.
|
|
function getSetOffset(input, keepLocalTime, keepMinutes) {
|
|
var offset = this._offset || 0,
|
|
localAdjust;
|
|
if (!this.isValid()) {
|
|
return input != null ? this : NaN;
|
|
}
|
|
if (input != null) {
|
|
if (typeof input === 'string') {
|
|
input = offsetFromString(matchShortOffset, input);
|
|
if (input === null) {
|
|
return this;
|
|
}
|
|
} else if (Math.abs(input) < 16 && !keepMinutes) {
|
|
input = input * 60;
|
|
}
|
|
if (!this._isUTC && keepLocalTime) {
|
|
localAdjust = getDateOffset(this);
|
|
}
|
|
this._offset = input;
|
|
this._isUTC = true;
|
|
if (localAdjust != null) {
|
|
this.add(localAdjust, 'm');
|
|
}
|
|
if (offset !== input) {
|
|
if (!keepLocalTime || this._changeInProgress) {
|
|
addSubtract(
|
|
this,
|
|
createDuration(input - offset, 'm'),
|
|
1,
|
|
false
|
|
);
|
|
} else if (!this._changeInProgress) {
|
|
this._changeInProgress = true;
|
|
hooks.updateOffset(this, true);
|
|
this._changeInProgress = null;
|
|
}
|
|
}
|
|
return this;
|
|
} else {
|
|
return this._isUTC ? offset : getDateOffset(this);
|
|
}
|
|
}
|
|
|
|
function getSetZone(input, keepLocalTime) {
|
|
if (input != null) {
|
|
if (typeof input !== 'string') {
|
|
input = -input;
|
|
}
|
|
|
|
this.utcOffset(input, keepLocalTime);
|
|
|
|
return this;
|
|
} else {
|
|
return -this.utcOffset();
|
|
}
|
|
}
|
|
|
|
function setOffsetToUTC(keepLocalTime) {
|
|
return this.utcOffset(0, keepLocalTime);
|
|
}
|
|
|
|
function setOffsetToLocal(keepLocalTime) {
|
|
if (this._isUTC) {
|
|
this.utcOffset(0, keepLocalTime);
|
|
this._isUTC = false;
|
|
|
|
if (keepLocalTime) {
|
|
this.subtract(getDateOffset(this), 'm');
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
function setOffsetToParsedOffset() {
|
|
if (this._tzm != null) {
|
|
this.utcOffset(this._tzm, false, true);
|
|
} else if (typeof this._i === 'string') {
|
|
var tZone = offsetFromString(matchOffset, this._i);
|
|
if (tZone != null) {
|
|
this.utcOffset(tZone);
|
|
} else {
|
|
this.utcOffset(0, true);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
function hasAlignedHourOffset(input) {
|
|
if (!this.isValid()) {
|
|
return false;
|
|
}
|
|
input = input ? createLocal(input).utcOffset() : 0;
|
|
|
|
return (this.utcOffset() - input) % 60 === 0;
|
|
}
|
|
|
|
function isDaylightSavingTime() {
|
|
return (
|
|
this.utcOffset() > this.clone().month(0).utcOffset() ||
|
|
this.utcOffset() > this.clone().month(5).utcOffset()
|
|
);
|
|
}
|
|
|
|
function isDaylightSavingTimeShifted() {
|
|
if (!isUndefined(this._isDSTShifted)) {
|
|
return this._isDSTShifted;
|
|
}
|
|
|
|
var c = {},
|
|
other;
|
|
|
|
copyConfig(c, this);
|
|
c = prepareConfig(c);
|
|
|
|
if (c._a) {
|
|
other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
|
|
this._isDSTShifted =
|
|
this.isValid() && compareArrays(c._a, other.toArray()) > 0;
|
|
} else {
|
|
this._isDSTShifted = false;
|
|
}
|
|
|
|
return this._isDSTShifted;
|
|
}
|
|
|
|
function isLocal() {
|
|
return this.isValid() ? !this._isUTC : false;
|
|
}
|
|
|
|
function isUtcOffset() {
|
|
return this.isValid() ? this._isUTC : false;
|
|
}
|
|
|
|
function isUtc() {
|
|
return this.isValid() ? this._isUTC && this._offset === 0 : false;
|
|
}
|
|
|
|
// ASP.NET json date format regex
|
|
var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/,
|
|
// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
|
|
// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
|
|
// and further modified to allow for strings containing both week and day
|
|
isoRegex =
|
|
/^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
|
|
|
|
function createDuration(input, key) {
|
|
var duration = input,
|
|
// matching against regexp is expensive, do it on demand
|
|
match = null,
|
|
sign,
|
|
ret,
|
|
diffRes;
|
|
|
|
if (isDuration(input)) {
|
|
duration = {
|
|
ms: input._milliseconds,
|
|
d: input._days,
|
|
M: input._months,
|
|
};
|
|
} else if (isNumber(input) || !isNaN(+input)) {
|
|
duration = {};
|
|
if (key) {
|
|
duration[key] = +input;
|
|
} else {
|
|
duration.milliseconds = +input;
|
|
}
|
|
} else if ((match = aspNetRegex.exec(input))) {
|
|
sign = match[1] === '-' ? -1 : 1;
|
|
duration = {
|
|
y: 0,
|
|
d: toInt(match[DATE]) * sign,
|
|
h: toInt(match[HOUR]) * sign,
|
|
m: toInt(match[MINUTE]) * sign,
|
|
s: toInt(match[SECOND]) * sign,
|
|
ms: toInt(absRound(match[MILLISECOND] * 1000)) * sign, // the millisecond decimal point is included in the match
|
|
};
|
|
} else if ((match = isoRegex.exec(input))) {
|
|
sign = match[1] === '-' ? -1 : 1;
|
|
duration = {
|
|
y: parseIso(match[2], sign),
|
|
M: parseIso(match[3], sign),
|
|
w: parseIso(match[4], sign),
|
|
d: parseIso(match[5], sign),
|
|
h: parseIso(match[6], sign),
|
|
m: parseIso(match[7], sign),
|
|
s: parseIso(match[8], sign),
|
|
};
|
|
} else if (duration == null) {
|
|
// checks for null or undefined
|
|
duration = {};
|
|
} else if (
|
|
typeof duration === 'object' &&
|
|
('from' in duration || 'to' in duration)
|
|
) {
|
|
diffRes = momentsDifference(
|
|
createLocal(duration.from),
|
|
createLocal(duration.to)
|
|
);
|
|
|
|
duration = {};
|
|
duration.ms = diffRes.milliseconds;
|
|
duration.M = diffRes.months;
|
|
}
|
|
|
|
ret = new Duration(duration);
|
|
|
|
if (isDuration(input) && hasOwnProp(input, '_locale')) {
|
|
ret._locale = input._locale;
|
|
}
|
|
|
|
if (isDuration(input) && hasOwnProp(input, '_isValid')) {
|
|
ret._isValid = input._isValid;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
createDuration.fn = Duration.prototype;
|
|
createDuration.invalid = createInvalid$1;
|
|
|
|
function parseIso(inp, sign) {
|
|
// We'd normally use ~~inp for this, but unfortunately it also
|
|
// converts floats to ints.
|
|
// inp may be undefined, so careful calling replace on it.
|
|
var res = inp && parseFloat(inp.replace(',', '.'));
|
|
// apply sign while we're at it
|
|
return (isNaN(res) ? 0 : res) * sign;
|
|
}
|
|
|
|
function positiveMomentsDifference(base, other) {
|
|
var res = {};
|
|
|
|
res.months =
|
|
other.month() - base.month() + (other.year() - base.year()) * 12;
|
|
if (base.clone().add(res.months, 'M').isAfter(other)) {
|
|
--res.months;
|
|
}
|
|
|
|
res.milliseconds = +other - +base.clone().add(res.months, 'M');
|
|
|
|
return res;
|
|
}
|
|
|
|
function momentsDifference(base, other) {
|
|
var res;
|
|
if (!(base.isValid() && other.isValid())) {
|
|
return { milliseconds: 0, months: 0 };
|
|
}
|
|
|
|
other = cloneWithOffset(other, base);
|
|
if (base.isBefore(other)) {
|
|
res = positiveMomentsDifference(base, other);
|
|
} else {
|
|
res = positiveMomentsDifference(other, base);
|
|
res.milliseconds = -res.milliseconds;
|
|
res.months = -res.months;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
// TODO: remove 'name' arg after deprecation is removed
|
|
function createAdder(direction, name) {
|
|
return function (val, period) {
|
|
var dur, tmp;
|
|
//invert the arguments, but complain about it
|
|
if (period !== null && !isNaN(+period)) {
|
|
deprecateSimple(
|
|
name,
|
|
'moment().' +
|
|
name +
|
|
'(period, number) is deprecated. Please use moment().' +
|
|
name +
|
|
'(number, period). ' +
|
|
'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'
|
|
);
|
|
tmp = val;
|
|
val = period;
|
|
period = tmp;
|
|
}
|
|
|
|
dur = createDuration(val, period);
|
|
addSubtract(this, dur, direction);
|
|
return this;
|
|
};
|
|
}
|
|
|
|
function addSubtract(mom, duration, isAdding, updateOffset) {
|
|
var milliseconds = duration._milliseconds,
|
|
days = absRound(duration._days),
|
|
months = absRound(duration._months);
|
|
|
|
if (!mom.isValid()) {
|
|
// No op
|
|
return;
|
|
}
|
|
|
|
updateOffset = updateOffset == null ? true : updateOffset;
|
|
|
|
if (months) {
|
|
setMonth(mom, get(mom, 'Month') + months * isAdding);
|
|
}
|
|
if (days) {
|
|
set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
|
|
}
|
|
if (milliseconds) {
|
|
mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
|
|
}
|
|
if (updateOffset) {
|
|
hooks.updateOffset(mom, days || months);
|
|
}
|
|
}
|
|
|
|
var add = createAdder(1, 'add'),
|
|
subtract = createAdder(-1, 'subtract');
|
|
|
|
function isString(input) {
|
|
return typeof input === 'string' || input instanceof String;
|
|
}
|
|
|
|
// type MomentInput = Moment | Date | string | number | (number | string)[] | MomentInputObject | void; // null | undefined
|
|
function isMomentInput(input) {
|
|
return (
|
|
isMoment(input) ||
|
|
isDate(input) ||
|
|
isString(input) ||
|
|
isNumber(input) ||
|
|
isNumberOrStringArray(input) ||
|
|
isMomentInputObject(input) ||
|
|
input === null ||
|
|
input === undefined
|
|
);
|
|
}
|
|
|
|
function isMomentInputObject(input) {
|
|
var objectTest = isObject(input) && !isObjectEmpty(input),
|
|
propertyTest = false,
|
|
properties = [
|
|
'years',
|
|
'year',
|
|
'y',
|
|
'months',
|
|
'month',
|
|
'M',
|
|
'days',
|
|
'day',
|
|
'd',
|
|
'dates',
|
|
'date',
|
|
'D',
|
|
'hours',
|
|
'hour',
|
|
'h',
|
|
'minutes',
|
|
'minute',
|
|
'm',
|
|
'seconds',
|
|
'second',
|
|
's',
|
|
'milliseconds',
|
|
'millisecond',
|
|
'ms',
|
|
],
|
|
i,
|
|
property,
|
|
propertyLen = properties.length;
|
|
|
|
for (i = 0; i < propertyLen; i += 1) {
|
|
property = properties[i];
|
|
propertyTest = propertyTest || hasOwnProp(input, property);
|
|
}
|
|
|
|
return objectTest && propertyTest;
|
|
}
|
|
|
|
function isNumberOrStringArray(input) {
|
|
var arrayTest = isArray(input),
|
|
dataTypeTest = false;
|
|
if (arrayTest) {
|
|
dataTypeTest =
|
|
input.filter(function (item) {
|
|
return !isNumber(item) && isString(input);
|
|
}).length === 0;
|
|
}
|
|
return arrayTest && dataTypeTest;
|
|
}
|
|
|
|
function isCalendarSpec(input) {
|
|
var objectTest = isObject(input) && !isObjectEmpty(input),
|
|
propertyTest = false,
|
|
properties = [
|
|
'sameDay',
|
|
'nextDay',
|
|
'lastDay',
|
|
'nextWeek',
|
|
'lastWeek',
|
|
'sameElse',
|
|
],
|
|
i,
|
|
property;
|
|
|
|
for (i = 0; i < properties.length; i += 1) {
|
|
property = properties[i];
|
|
propertyTest = propertyTest || hasOwnProp(input, property);
|
|
}
|
|
|
|
return objectTest && propertyTest;
|
|
}
|
|
|
|
function getCalendarFormat(myMoment, now) {
|
|
var diff = myMoment.diff(now, 'days', true);
|
|
return diff < -6
|
|
? 'sameElse'
|
|
: diff < -1
|
|
? 'lastWeek'
|
|
: diff < 0
|
|
? 'lastDay'
|
|
: diff < 1
|
|
? 'sameDay'
|
|
: diff < 2
|
|
? 'nextDay'
|
|
: diff < 7
|
|
? 'nextWeek'
|
|
: 'sameElse';
|
|
}
|
|
|
|
function calendar$1(time, formats) {
|
|
// Support for single parameter, formats only overload to the calendar function
|
|
if (arguments.length === 1) {
|
|
if (!arguments[0]) {
|
|
time = undefined;
|
|
formats = undefined;
|
|
} else if (isMomentInput(arguments[0])) {
|
|
time = arguments[0];
|
|
formats = undefined;
|
|
} else if (isCalendarSpec(arguments[0])) {
|
|
formats = arguments[0];
|
|
time = undefined;
|
|
}
|
|
}
|
|
// We want to compare the start of today, vs this.
|
|
// Getting start-of-today depends on whether we're local/utc/offset or not.
|
|
var now = time || createLocal(),
|
|
sod = cloneWithOffset(now, this).startOf('day'),
|
|
format = hooks.calendarFormat(this, sod) || 'sameElse',
|
|
output =
|
|
formats &&
|
|
(isFunction(formats[format])
|
|
? formats[format].call(this, now)
|
|
: formats[format]);
|
|
|
|
return this.format(
|
|
output || this.localeData().calendar(format, this, createLocal(now))
|
|
);
|
|
}
|
|
|
|
function clone() {
|
|
return new Moment(this);
|
|
}
|
|
|
|
function isAfter(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input);
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || 'millisecond';
|
|
if (units === 'millisecond') {
|
|
return this.valueOf() > localInput.valueOf();
|
|
} else {
|
|
return localInput.valueOf() < this.clone().startOf(units).valueOf();
|
|
}
|
|
}
|
|
|
|
function isBefore(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input);
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || 'millisecond';
|
|
if (units === 'millisecond') {
|
|
return this.valueOf() < localInput.valueOf();
|
|
} else {
|
|
return this.clone().endOf(units).valueOf() < localInput.valueOf();
|
|
}
|
|
}
|
|
|
|
function isBetween(from, to, units, inclusivity) {
|
|
var localFrom = isMoment(from) ? from : createLocal(from),
|
|
localTo = isMoment(to) ? to : createLocal(to);
|
|
if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
|
|
return false;
|
|
}
|
|
inclusivity = inclusivity || '()';
|
|
return (
|
|
(inclusivity[0] === '('
|
|
? this.isAfter(localFrom, units)
|
|
: !this.isBefore(localFrom, units)) &&
|
|
(inclusivity[1] === ')'
|
|
? this.isBefore(localTo, units)
|
|
: !this.isAfter(localTo, units))
|
|
);
|
|
}
|
|
|
|
function isSame(input, units) {
|
|
var localInput = isMoment(input) ? input : createLocal(input),
|
|
inputMs;
|
|
if (!(this.isValid() && localInput.isValid())) {
|
|
return false;
|
|
}
|
|
units = normalizeUnits(units) || 'millisecond';
|
|
if (units === 'millisecond') {
|
|
return this.valueOf() === localInput.valueOf();
|
|
} else {
|
|
inputMs = localInput.valueOf();
|
|
return (
|
|
this.clone().startOf(units).valueOf() <= inputMs &&
|
|
inputMs <= this.clone().endOf(units).valueOf()
|
|
);
|
|
}
|
|
}
|
|
|
|
function isSameOrAfter(input, units) {
|
|
return this.isSame(input, units) || this.isAfter(input, units);
|
|
}
|
|
|
|
function isSameOrBefore(input, units) {
|
|
return this.isSame(input, units) || this.isBefore(input, units);
|
|
}
|
|
|
|
function diff(input, units, asFloat) {
|
|
var that, zoneDelta, output;
|
|
|
|
if (!this.isValid()) {
|
|
return NaN;
|
|
}
|
|
|
|
that = cloneWithOffset(input, this);
|
|
|
|
if (!that.isValid()) {
|
|
return NaN;
|
|
}
|
|
|
|
zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
|
|
|
|
units = normalizeUnits(units);
|
|
|
|
switch (units) {
|
|
case 'year':
|
|
output = monthDiff(this, that) / 12;
|
|
break;
|
|
case 'month':
|
|
output = monthDiff(this, that);
|
|
break;
|
|
case 'quarter':
|
|
output = monthDiff(this, that) / 3;
|
|
break;
|
|
case 'second':
|
|
output = (this - that) / 1e3;
|
|
break; // 1000
|
|
case 'minute':
|
|
output = (this - that) / 6e4;
|
|
break; // 1000 * 60
|
|
case 'hour':
|
|
output = (this - that) / 36e5;
|
|
break; // 1000 * 60 * 60
|
|
case 'day':
|
|
output = (this - that - zoneDelta) / 864e5;
|
|
break; // 1000 * 60 * 60 * 24, negate dst
|
|
case 'week':
|
|
output = (this - that - zoneDelta) / 6048e5;
|
|
break; // 1000 * 60 * 60 * 24 * 7, negate dst
|
|
default:
|
|
output = this - that;
|
|
}
|
|
|
|
return asFloat ? output : absFloor(output);
|
|
}
|
|
|
|
function monthDiff(a, b) {
|
|
if (a.date() < b.date()) {
|
|
// end-of-month calculations work correct when the start month has more
|
|
// days than the end month.
|
|
return -monthDiff(b, a);
|
|
}
|
|
// difference in months
|
|
var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
|
|
// b is in (anchor - 1 month, anchor + 1 month)
|
|
anchor = a.clone().add(wholeMonthDiff, 'months'),
|
|
anchor2,
|
|
adjust;
|
|
|
|
if (b - anchor < 0) {
|
|
anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
|
|
// linear across the month
|
|
adjust = (b - anchor) / (anchor - anchor2);
|
|
} else {
|
|
anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
|
|
// linear across the month
|
|
adjust = (b - anchor) / (anchor2 - anchor);
|
|
}
|
|
|
|
//check for negative zero, return zero if negative zero
|
|
return -(wholeMonthDiff + adjust) || 0;
|
|
}
|
|
|
|
hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
|
|
hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
|
|
|
|
function toString() {
|
|
return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
|
|
}
|
|
|
|
function toISOString(keepOffset) {
|
|
if (!this.isValid()) {
|
|
return null;
|
|
}
|
|
var utc = keepOffset !== true,
|
|
m = utc ? this.clone().utc() : this;
|
|
if (m.year() < 0 || m.year() > 9999) {
|
|
return formatMoment(
|
|
m,
|
|
utc
|
|
? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]'
|
|
: 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'
|
|
);
|
|
}
|
|
if (isFunction(Date.prototype.toISOString)) {
|
|
// native implementation is ~50x faster, use it when we can
|
|
if (utc) {
|
|
return this.toDate().toISOString();
|
|
} else {
|
|
return new Date(this.valueOf() + this.utcOffset() * 60 * 1000)
|
|
.toISOString()
|
|
.replace('Z', formatMoment(m, 'Z'));
|
|
}
|
|
}
|
|
return formatMoment(
|
|
m,
|
|
utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Return a human readable representation of a moment that can
|
|
* also be evaluated to get a new moment which is the same
|
|
*
|
|
* @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
|
|
*/
|
|
function inspect() {
|
|
if (!this.isValid()) {
|
|
return 'moment.invalid(/* ' + this._i + ' */)';
|
|
}
|
|
var func = 'moment',
|
|
zone = '',
|
|
prefix,
|
|
year,
|
|
datetime,
|
|
suffix;
|
|
if (!this.isLocal()) {
|
|
func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
|
|
zone = 'Z';
|
|
}
|
|
prefix = '[' + func + '("]';
|
|
year = 0 <= this.year() && this.year() <= 9999 ? 'YYYY' : 'YYYYYY';
|
|
datetime = '-MM-DD[T]HH:mm:ss.SSS';
|
|
suffix = zone + '[")]';
|
|
|
|
return this.format(prefix + year + datetime + suffix);
|
|
}
|
|
|
|
function format(inputString) {
|
|
if (!inputString) {
|
|
inputString = this.isUtc()
|
|
? hooks.defaultFormatUtc
|
|
: hooks.defaultFormat;
|
|
}
|
|
var output = formatMoment(this, inputString);
|
|
return this.localeData().postformat(output);
|
|
}
|
|
|
|
function from(time, withoutSuffix) {
|
|
if (
|
|
this.isValid() &&
|
|
((isMoment(time) && time.isValid()) || createLocal(time).isValid())
|
|
) {
|
|
return createDuration({ to: this, from: time })
|
|
.locale(this.locale())
|
|
.humanize(!withoutSuffix);
|
|
} else {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
}
|
|
|
|
function fromNow(withoutSuffix) {
|
|
return this.from(createLocal(), withoutSuffix);
|
|
}
|
|
|
|
function to(time, withoutSuffix) {
|
|
if (
|
|
this.isValid() &&
|
|
((isMoment(time) && time.isValid()) || createLocal(time).isValid())
|
|
) {
|
|
return createDuration({ from: this, to: time })
|
|
.locale(this.locale())
|
|
.humanize(!withoutSuffix);
|
|
} else {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
}
|
|
|
|
function toNow(withoutSuffix) {
|
|
return this.to(createLocal(), withoutSuffix);
|
|
}
|
|
|
|
// If passed a locale key, it will set the locale for this
|
|
// instance. Otherwise, it will return the locale configuration
|
|
// variables for this instance.
|
|
function locale(key) {
|
|
var newLocaleData;
|
|
|
|
if (key === undefined) {
|
|
return this._locale._abbr;
|
|
} else {
|
|
newLocaleData = getLocale(key);
|
|
if (newLocaleData != null) {
|
|
this._locale = newLocaleData;
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
|
|
var lang = deprecate(
|
|
'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
|
|
function (key) {
|
|
if (key === undefined) {
|
|
return this.localeData();
|
|
} else {
|
|
return this.locale(key);
|
|
}
|
|
}
|
|
);
|
|
|
|
function localeData() {
|
|
return this._locale;
|
|
}
|
|
|
|
var MS_PER_SECOND = 1000,
|
|
MS_PER_MINUTE = 60 * MS_PER_SECOND,
|
|
MS_PER_HOUR = 60 * MS_PER_MINUTE,
|
|
MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
|
|
|
|
// actual modulo - handles negative numbers (for dates before 1970):
|
|
function mod$1(dividend, divisor) {
|
|
return ((dividend % divisor) + divisor) % divisor;
|
|
}
|
|
|
|
function localStartOfDate(y, m, d) {
|
|
// the date constructor remaps years 0-99 to 1900-1999
|
|
if (y < 100 && y >= 0) {
|
|
// preserve leap years using a full 400 year cycle, then reset
|
|
return new Date(y + 400, m, d) - MS_PER_400_YEARS;
|
|
} else {
|
|
return new Date(y, m, d).valueOf();
|
|
}
|
|
}
|
|
|
|
function utcStartOfDate(y, m, d) {
|
|
// Date.UTC remaps years 0-99 to 1900-1999
|
|
if (y < 100 && y >= 0) {
|
|
// preserve leap years using a full 400 year cycle, then reset
|
|
return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
|
|
} else {
|
|
return Date.UTC(y, m, d);
|
|
}
|
|
}
|
|
|
|
function startOf(units) {
|
|
var time, startOfDate;
|
|
units = normalizeUnits(units);
|
|
if (units === undefined || units === 'millisecond' || !this.isValid()) {
|
|
return this;
|
|
}
|
|
|
|
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
|
|
|
|
switch (units) {
|
|
case 'year':
|
|
time = startOfDate(this.year(), 0, 1);
|
|
break;
|
|
case 'quarter':
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month() - (this.month() % 3),
|
|
1
|
|
);
|
|
break;
|
|
case 'month':
|
|
time = startOfDate(this.year(), this.month(), 1);
|
|
break;
|
|
case 'week':
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - this.weekday()
|
|
);
|
|
break;
|
|
case 'isoWeek':
|
|
time = startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - (this.isoWeekday() - 1)
|
|
);
|
|
break;
|
|
case 'day':
|
|
case 'date':
|
|
time = startOfDate(this.year(), this.month(), this.date());
|
|
break;
|
|
case 'hour':
|
|
time = this._d.valueOf();
|
|
time -= mod$1(
|
|
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
|
|
MS_PER_HOUR
|
|
);
|
|
break;
|
|
case 'minute':
|
|
time = this._d.valueOf();
|
|
time -= mod$1(time, MS_PER_MINUTE);
|
|
break;
|
|
case 'second':
|
|
time = this._d.valueOf();
|
|
time -= mod$1(time, MS_PER_SECOND);
|
|
break;
|
|
}
|
|
|
|
this._d.setTime(time);
|
|
hooks.updateOffset(this, true);
|
|
return this;
|
|
}
|
|
|
|
function endOf(units) {
|
|
var time, startOfDate;
|
|
units = normalizeUnits(units);
|
|
if (units === undefined || units === 'millisecond' || !this.isValid()) {
|
|
return this;
|
|
}
|
|
|
|
startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
|
|
|
|
switch (units) {
|
|
case 'year':
|
|
time = startOfDate(this.year() + 1, 0, 1) - 1;
|
|
break;
|
|
case 'quarter':
|
|
time =
|
|
startOfDate(
|
|
this.year(),
|
|
this.month() - (this.month() % 3) + 3,
|
|
1
|
|
) - 1;
|
|
break;
|
|
case 'month':
|
|
time = startOfDate(this.year(), this.month() + 1, 1) - 1;
|
|
break;
|
|
case 'week':
|
|
time =
|
|
startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - this.weekday() + 7
|
|
) - 1;
|
|
break;
|
|
case 'isoWeek':
|
|
time =
|
|
startOfDate(
|
|
this.year(),
|
|
this.month(),
|
|
this.date() - (this.isoWeekday() - 1) + 7
|
|
) - 1;
|
|
break;
|
|
case 'day':
|
|
case 'date':
|
|
time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
|
|
break;
|
|
case 'hour':
|
|
time = this._d.valueOf();
|
|
time +=
|
|
MS_PER_HOUR -
|
|
mod$1(
|
|
time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE),
|
|
MS_PER_HOUR
|
|
) -
|
|
1;
|
|
break;
|
|
case 'minute':
|
|
time = this._d.valueOf();
|
|
time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
|
|
break;
|
|
case 'second':
|
|
time = this._d.valueOf();
|
|
time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
|
|
break;
|
|
}
|
|
|
|
this._d.setTime(time);
|
|
hooks.updateOffset(this, true);
|
|
return this;
|
|
}
|
|
|
|
function valueOf() {
|
|
return this._d.valueOf() - (this._offset || 0) * 60000;
|
|
}
|
|
|
|
function unix() {
|
|
return Math.floor(this.valueOf() / 1000);
|
|
}
|
|
|
|
function toDate() {
|
|
return new Date(this.valueOf());
|
|
}
|
|
|
|
function toArray() {
|
|
var m = this;
|
|
return [
|
|
m.year(),
|
|
m.month(),
|
|
m.date(),
|
|
m.hour(),
|
|
m.minute(),
|
|
m.second(),
|
|
m.millisecond(),
|
|
];
|
|
}
|
|
|
|
function toObject() {
|
|
var m = this;
|
|
return {
|
|
years: m.year(),
|
|
months: m.month(),
|
|
date: m.date(),
|
|
hours: m.hours(),
|
|
minutes: m.minutes(),
|
|
seconds: m.seconds(),
|
|
milliseconds: m.milliseconds(),
|
|
};
|
|
}
|
|
|
|
function toJSON() {
|
|
// new Date(NaN).toJSON() === null
|
|
return this.isValid() ? this.toISOString() : null;
|
|
}
|
|
|
|
function isValid$2() {
|
|
return isValid(this);
|
|
}
|
|
|
|
function parsingFlags() {
|
|
return extend({}, getParsingFlags(this));
|
|
}
|
|
|
|
function invalidAt() {
|
|
return getParsingFlags(this).overflow;
|
|
}
|
|
|
|
function creationData() {
|
|
return {
|
|
input: this._i,
|
|
format: this._f,
|
|
locale: this._locale,
|
|
isUTC: this._isUTC,
|
|
strict: this._strict,
|
|
};
|
|
}
|
|
|
|
addFormatToken('N', 0, 0, 'eraAbbr');
|
|
addFormatToken('NN', 0, 0, 'eraAbbr');
|
|
addFormatToken('NNN', 0, 0, 'eraAbbr');
|
|
addFormatToken('NNNN', 0, 0, 'eraName');
|
|
addFormatToken('NNNNN', 0, 0, 'eraNarrow');
|
|
|
|
addFormatToken('y', ['y', 1], 'yo', 'eraYear');
|
|
addFormatToken('y', ['yy', 2], 0, 'eraYear');
|
|
addFormatToken('y', ['yyy', 3], 0, 'eraYear');
|
|
addFormatToken('y', ['yyyy', 4], 0, 'eraYear');
|
|
|
|
addRegexToken('N', matchEraAbbr);
|
|
addRegexToken('NN', matchEraAbbr);
|
|
addRegexToken('NNN', matchEraAbbr);
|
|
addRegexToken('NNNN', matchEraName);
|
|
addRegexToken('NNNNN', matchEraNarrow);
|
|
|
|
addParseToken(
|
|
['N', 'NN', 'NNN', 'NNNN', 'NNNNN'],
|
|
function (input, array, config, token) {
|
|
var era = config._locale.erasParse(input, token, config._strict);
|
|
if (era) {
|
|
getParsingFlags(config).era = era;
|
|
} else {
|
|
getParsingFlags(config).invalidEra = input;
|
|
}
|
|
}
|
|
);
|
|
|
|
addRegexToken('y', matchUnsigned);
|
|
addRegexToken('yy', matchUnsigned);
|
|
addRegexToken('yyy', matchUnsigned);
|
|
addRegexToken('yyyy', matchUnsigned);
|
|
addRegexToken('yo', matchEraYearOrdinal);
|
|
|
|
addParseToken(['y', 'yy', 'yyy', 'yyyy'], YEAR);
|
|
addParseToken(['yo'], function (input, array, config, token) {
|
|
var match;
|
|
if (config._locale._eraYearOrdinalRegex) {
|
|
match = input.match(config._locale._eraYearOrdinalRegex);
|
|
}
|
|
|
|
if (config._locale.eraYearOrdinalParse) {
|
|
array[YEAR] = config._locale.eraYearOrdinalParse(input, match);
|
|
} else {
|
|
array[YEAR] = parseInt(input, 10);
|
|
}
|
|
});
|
|
|
|
function localeEras(m, format) {
|
|
var i,
|
|
l,
|
|
date,
|
|
eras = this._eras || getLocale('en')._eras;
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
switch (typeof eras[i].since) {
|
|
case 'string':
|
|
// truncate time
|
|
date = hooks(eras[i].since).startOf('day');
|
|
eras[i].since = date.valueOf();
|
|
break;
|
|
}
|
|
|
|
switch (typeof eras[i].until) {
|
|
case 'undefined':
|
|
eras[i].until = +Infinity;
|
|
break;
|
|
case 'string':
|
|
// truncate time
|
|
date = hooks(eras[i].until).startOf('day').valueOf();
|
|
eras[i].until = date.valueOf();
|
|
break;
|
|
}
|
|
}
|
|
return eras;
|
|
}
|
|
|
|
function localeErasParse(eraName, format, strict) {
|
|
var i,
|
|
l,
|
|
eras = this.eras(),
|
|
name,
|
|
abbr,
|
|
narrow;
|
|
eraName = eraName.toUpperCase();
|
|
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
name = eras[i].name.toUpperCase();
|
|
abbr = eras[i].abbr.toUpperCase();
|
|
narrow = eras[i].narrow.toUpperCase();
|
|
|
|
if (strict) {
|
|
switch (format) {
|
|
case 'N':
|
|
case 'NN':
|
|
case 'NNN':
|
|
if (abbr === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
|
|
case 'NNNN':
|
|
if (name === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
|
|
case 'NNNNN':
|
|
if (narrow === eraName) {
|
|
return eras[i];
|
|
}
|
|
break;
|
|
}
|
|
} else if ([name, abbr, narrow].indexOf(eraName) >= 0) {
|
|
return eras[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
function localeErasConvertYear(era, year) {
|
|
var dir = era.since <= era.until ? +1 : -1;
|
|
if (year === undefined) {
|
|
return hooks(era.since).year();
|
|
} else {
|
|
return hooks(era.since).year() + (year - era.offset) * dir;
|
|
}
|
|
}
|
|
|
|
function getEraName() {
|
|
var i,
|
|
l,
|
|
val,
|
|
eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
// truncate time
|
|
val = this.clone().startOf('day').valueOf();
|
|
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].name;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].name;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
function getEraNarrow() {
|
|
var i,
|
|
l,
|
|
val,
|
|
eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
// truncate time
|
|
val = this.clone().startOf('day').valueOf();
|
|
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].narrow;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].narrow;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
function getEraAbbr() {
|
|
var i,
|
|
l,
|
|
val,
|
|
eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
// truncate time
|
|
val = this.clone().startOf('day').valueOf();
|
|
|
|
if (eras[i].since <= val && val <= eras[i].until) {
|
|
return eras[i].abbr;
|
|
}
|
|
if (eras[i].until <= val && val <= eras[i].since) {
|
|
return eras[i].abbr;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
|
|
function getEraYear() {
|
|
var i,
|
|
l,
|
|
dir,
|
|
val,
|
|
eras = this.localeData().eras();
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
dir = eras[i].since <= eras[i].until ? +1 : -1;
|
|
|
|
// truncate time
|
|
val = this.clone().startOf('day').valueOf();
|
|
|
|
if (
|
|
(eras[i].since <= val && val <= eras[i].until) ||
|
|
(eras[i].until <= val && val <= eras[i].since)
|
|
) {
|
|
return (
|
|
(this.year() - hooks(eras[i].since).year()) * dir +
|
|
eras[i].offset
|
|
);
|
|
}
|
|
}
|
|
|
|
return this.year();
|
|
}
|
|
|
|
function erasNameRegex(isStrict) {
|
|
if (!hasOwnProp(this, '_erasNameRegex')) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasNameRegex : this._erasRegex;
|
|
}
|
|
|
|
function erasAbbrRegex(isStrict) {
|
|
if (!hasOwnProp(this, '_erasAbbrRegex')) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasAbbrRegex : this._erasRegex;
|
|
}
|
|
|
|
function erasNarrowRegex(isStrict) {
|
|
if (!hasOwnProp(this, '_erasNarrowRegex')) {
|
|
computeErasParse.call(this);
|
|
}
|
|
return isStrict ? this._erasNarrowRegex : this._erasRegex;
|
|
}
|
|
|
|
function matchEraAbbr(isStrict, locale) {
|
|
return locale.erasAbbrRegex(isStrict);
|
|
}
|
|
|
|
function matchEraName(isStrict, locale) {
|
|
return locale.erasNameRegex(isStrict);
|
|
}
|
|
|
|
function matchEraNarrow(isStrict, locale) {
|
|
return locale.erasNarrowRegex(isStrict);
|
|
}
|
|
|
|
function matchEraYearOrdinal(isStrict, locale) {
|
|
return locale._eraYearOrdinalRegex || matchUnsigned;
|
|
}
|
|
|
|
function computeErasParse() {
|
|
var abbrPieces = [],
|
|
namePieces = [],
|
|
narrowPieces = [],
|
|
mixedPieces = [],
|
|
i,
|
|
l,
|
|
erasName,
|
|
erasAbbr,
|
|
erasNarrow,
|
|
eras = this.eras();
|
|
|
|
for (i = 0, l = eras.length; i < l; ++i) {
|
|
erasName = regexEscape(eras[i].name);
|
|
erasAbbr = regexEscape(eras[i].abbr);
|
|
erasNarrow = regexEscape(eras[i].narrow);
|
|
|
|
namePieces.push(erasName);
|
|
abbrPieces.push(erasAbbr);
|
|
narrowPieces.push(erasNarrow);
|
|
mixedPieces.push(erasName);
|
|
mixedPieces.push(erasAbbr);
|
|
mixedPieces.push(erasNarrow);
|
|
}
|
|
|
|
this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
|
|
this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');
|
|
this._erasAbbrRegex = new RegExp('^(' + abbrPieces.join('|') + ')', 'i');
|
|
this._erasNarrowRegex = new RegExp(
|
|
'^(' + narrowPieces.join('|') + ')',
|
|
'i'
|
|
);
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken(0, ['gg', 2], 0, function () {
|
|
return this.weekYear() % 100;
|
|
});
|
|
|
|
addFormatToken(0, ['GG', 2], 0, function () {
|
|
return this.isoWeekYear() % 100;
|
|
});
|
|
|
|
function addWeekYearFormatToken(token, getter) {
|
|
addFormatToken(0, [token, token.length], 0, getter);
|
|
}
|
|
|
|
addWeekYearFormatToken('gggg', 'weekYear');
|
|
addWeekYearFormatToken('ggggg', 'weekYear');
|
|
addWeekYearFormatToken('GGGG', 'isoWeekYear');
|
|
addWeekYearFormatToken('GGGGG', 'isoWeekYear');
|
|
|
|
// ALIASES
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('G', matchSigned);
|
|
addRegexToken('g', matchSigned);
|
|
addRegexToken('GG', match1to2, match2);
|
|
addRegexToken('gg', match1to2, match2);
|
|
addRegexToken('GGGG', match1to4, match4);
|
|
addRegexToken('gggg', match1to4, match4);
|
|
addRegexToken('GGGGG', match1to6, match6);
|
|
addRegexToken('ggggg', match1to6, match6);
|
|
|
|
addWeekParseToken(
|
|
['gggg', 'ggggg', 'GGGG', 'GGGGG'],
|
|
function (input, week, config, token) {
|
|
week[token.substr(0, 2)] = toInt(input);
|
|
}
|
|
);
|
|
|
|
addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
|
|
week[token] = hooks.parseTwoDigitYear(input);
|
|
});
|
|
|
|
// MOMENTS
|
|
|
|
function getSetWeekYear(input) {
|
|
return getSetWeekYearHelper.call(
|
|
this,
|
|
input,
|
|
this.week(),
|
|
this.weekday() + this.localeData()._week.dow,
|
|
this.localeData()._week.dow,
|
|
this.localeData()._week.doy
|
|
);
|
|
}
|
|
|
|
function getSetISOWeekYear(input) {
|
|
return getSetWeekYearHelper.call(
|
|
this,
|
|
input,
|
|
this.isoWeek(),
|
|
this.isoWeekday(),
|
|
1,
|
|
4
|
|
);
|
|
}
|
|
|
|
function getISOWeeksInYear() {
|
|
return weeksInYear(this.year(), 1, 4);
|
|
}
|
|
|
|
function getISOWeeksInISOWeekYear() {
|
|
return weeksInYear(this.isoWeekYear(), 1, 4);
|
|
}
|
|
|
|
function getWeeksInYear() {
|
|
var weekInfo = this.localeData()._week;
|
|
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
|
|
}
|
|
|
|
function getWeeksInWeekYear() {
|
|
var weekInfo = this.localeData()._week;
|
|
return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy);
|
|
}
|
|
|
|
function getSetWeekYearHelper(input, week, weekday, dow, doy) {
|
|
var weeksTarget;
|
|
if (input == null) {
|
|
return weekOfYear(this, dow, doy).year;
|
|
} else {
|
|
weeksTarget = weeksInYear(input, dow, doy);
|
|
if (week > weeksTarget) {
|
|
week = weeksTarget;
|
|
}
|
|
return setWeekAll.call(this, input, week, weekday, dow, doy);
|
|
}
|
|
}
|
|
|
|
function setWeekAll(weekYear, week, weekday, dow, doy) {
|
|
var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
|
|
date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
|
|
|
|
this.year(date.getUTCFullYear());
|
|
this.month(date.getUTCMonth());
|
|
this.date(date.getUTCDate());
|
|
return this;
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('Q', 0, 'Qo', 'quarter');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('Q', match1);
|
|
addParseToken('Q', function (input, array) {
|
|
array[MONTH] = (toInt(input) - 1) * 3;
|
|
});
|
|
|
|
// MOMENTS
|
|
|
|
function getSetQuarter(input) {
|
|
return input == null
|
|
? Math.ceil((this.month() + 1) / 3)
|
|
: this.month((input - 1) * 3 + (this.month() % 3));
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('D', ['DD', 2], 'Do', 'date');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('D', match1to2, match1to2NoLeadingZero);
|
|
addRegexToken('DD', match1to2, match2);
|
|
addRegexToken('Do', function (isStrict, locale) {
|
|
// TODO: Remove "ordinalParse" fallback in next major release.
|
|
return isStrict
|
|
? locale._dayOfMonthOrdinalParse || locale._ordinalParse
|
|
: locale._dayOfMonthOrdinalParseLenient;
|
|
});
|
|
|
|
addParseToken(['D', 'DD'], DATE);
|
|
addParseToken('Do', function (input, array) {
|
|
array[DATE] = toInt(input.match(match1to2)[0]);
|
|
});
|
|
|
|
// MOMENTS
|
|
|
|
var getSetDayOfMonth = makeGetSet('Date', true);
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('DDD', match1to3);
|
|
addRegexToken('DDDD', match3);
|
|
addParseToken(['DDD', 'DDDD'], function (input, array, config) {
|
|
config._dayOfYear = toInt(input);
|
|
});
|
|
|
|
// HELPERS
|
|
|
|
// MOMENTS
|
|
|
|
function getSetDayOfYear(input) {
|
|
var dayOfYear =
|
|
Math.round(
|
|
(this.clone().startOf('day') - this.clone().startOf('year')) / 864e5
|
|
) + 1;
|
|
return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');
|
|
}
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('m', ['mm', 2], 0, 'minute');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('m', match1to2, match1to2HasZero);
|
|
addRegexToken('mm', match1to2, match2);
|
|
addParseToken(['m', 'mm'], MINUTE);
|
|
|
|
// MOMENTS
|
|
|
|
var getSetMinute = makeGetSet('Minutes', false);
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('s', ['ss', 2], 0, 'second');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('s', match1to2, match1to2HasZero);
|
|
addRegexToken('ss', match1to2, match2);
|
|
addParseToken(['s', 'ss'], SECOND);
|
|
|
|
// MOMENTS
|
|
|
|
var getSetSecond = makeGetSet('Seconds', false);
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('S', 0, 0, function () {
|
|
return ~~(this.millisecond() / 100);
|
|
});
|
|
|
|
addFormatToken(0, ['SS', 2], 0, function () {
|
|
return ~~(this.millisecond() / 10);
|
|
});
|
|
|
|
addFormatToken(0, ['SSS', 3], 0, 'millisecond');
|
|
addFormatToken(0, ['SSSS', 4], 0, function () {
|
|
return this.millisecond() * 10;
|
|
});
|
|
addFormatToken(0, ['SSSSS', 5], 0, function () {
|
|
return this.millisecond() * 100;
|
|
});
|
|
addFormatToken(0, ['SSSSSS', 6], 0, function () {
|
|
return this.millisecond() * 1000;
|
|
});
|
|
addFormatToken(0, ['SSSSSSS', 7], 0, function () {
|
|
return this.millisecond() * 10000;
|
|
});
|
|
addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
|
|
return this.millisecond() * 100000;
|
|
});
|
|
addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
|
|
return this.millisecond() * 1000000;
|
|
});
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('S', match1to3, match1);
|
|
addRegexToken('SS', match1to3, match2);
|
|
addRegexToken('SSS', match1to3, match3);
|
|
|
|
var token, getSetMillisecond;
|
|
for (token = 'SSSS'; token.length <= 9; token += 'S') {
|
|
addRegexToken(token, matchUnsigned);
|
|
}
|
|
|
|
function parseMs(input, array) {
|
|
array[MILLISECOND] = toInt(('0.' + input) * 1000);
|
|
}
|
|
|
|
for (token = 'S'; token.length <= 9; token += 'S') {
|
|
addParseToken(token, parseMs);
|
|
}
|
|
|
|
getSetMillisecond = makeGetSet('Milliseconds', false);
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('z', 0, 0, 'zoneAbbr');
|
|
addFormatToken('zz', 0, 0, 'zoneName');
|
|
|
|
// MOMENTS
|
|
|
|
function getZoneAbbr() {
|
|
return this._isUTC ? 'UTC' : '';
|
|
}
|
|
|
|
function getZoneName() {
|
|
return this._isUTC ? 'Coordinated Universal Time' : '';
|
|
}
|
|
|
|
var proto = Moment.prototype;
|
|
|
|
proto.add = add;
|
|
proto.calendar = calendar$1;
|
|
proto.clone = clone;
|
|
proto.diff = diff;
|
|
proto.endOf = endOf;
|
|
proto.format = format;
|
|
proto.from = from;
|
|
proto.fromNow = fromNow;
|
|
proto.to = to;
|
|
proto.toNow = toNow;
|
|
proto.get = stringGet;
|
|
proto.invalidAt = invalidAt;
|
|
proto.isAfter = isAfter;
|
|
proto.isBefore = isBefore;
|
|
proto.isBetween = isBetween;
|
|
proto.isSame = isSame;
|
|
proto.isSameOrAfter = isSameOrAfter;
|
|
proto.isSameOrBefore = isSameOrBefore;
|
|
proto.isValid = isValid$2;
|
|
proto.lang = lang;
|
|
proto.locale = locale;
|
|
proto.localeData = localeData;
|
|
proto.max = prototypeMax;
|
|
proto.min = prototypeMin;
|
|
proto.parsingFlags = parsingFlags;
|
|
proto.set = stringSet;
|
|
proto.startOf = startOf;
|
|
proto.subtract = subtract;
|
|
proto.toArray = toArray;
|
|
proto.toObject = toObject;
|
|
proto.toDate = toDate;
|
|
proto.toISOString = toISOString;
|
|
proto.inspect = inspect;
|
|
if (typeof Symbol !== 'undefined' && Symbol.for != null) {
|
|
proto[Symbol.for('nodejs.util.inspect.custom')] = function () {
|
|
return 'Moment<' + this.format() + '>';
|
|
};
|
|
}
|
|
proto.toJSON = toJSON;
|
|
proto.toString = toString;
|
|
proto.unix = unix;
|
|
proto.valueOf = valueOf;
|
|
proto.creationData = creationData;
|
|
proto.eraName = getEraName;
|
|
proto.eraNarrow = getEraNarrow;
|
|
proto.eraAbbr = getEraAbbr;
|
|
proto.eraYear = getEraYear;
|
|
proto.year = getSetYear;
|
|
proto.isLeapYear = getIsLeapYear;
|
|
proto.weekYear = getSetWeekYear;
|
|
proto.isoWeekYear = getSetISOWeekYear;
|
|
proto.quarter = proto.quarters = getSetQuarter;
|
|
proto.month = getSetMonth;
|
|
proto.daysInMonth = getDaysInMonth;
|
|
proto.week = proto.weeks = getSetWeek;
|
|
proto.isoWeek = proto.isoWeeks = getSetISOWeek;
|
|
proto.weeksInYear = getWeeksInYear;
|
|
proto.weeksInWeekYear = getWeeksInWeekYear;
|
|
proto.isoWeeksInYear = getISOWeeksInYear;
|
|
proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear;
|
|
proto.date = getSetDayOfMonth;
|
|
proto.day = proto.days = getSetDayOfWeek;
|
|
proto.weekday = getSetLocaleDayOfWeek;
|
|
proto.isoWeekday = getSetISODayOfWeek;
|
|
proto.dayOfYear = getSetDayOfYear;
|
|
proto.hour = proto.hours = getSetHour;
|
|
proto.minute = proto.minutes = getSetMinute;
|
|
proto.second = proto.seconds = getSetSecond;
|
|
proto.millisecond = proto.milliseconds = getSetMillisecond;
|
|
proto.utcOffset = getSetOffset;
|
|
proto.utc = setOffsetToUTC;
|
|
proto.local = setOffsetToLocal;
|
|
proto.parseZone = setOffsetToParsedOffset;
|
|
proto.hasAlignedHourOffset = hasAlignedHourOffset;
|
|
proto.isDST = isDaylightSavingTime;
|
|
proto.isLocal = isLocal;
|
|
proto.isUtcOffset = isUtcOffset;
|
|
proto.isUtc = isUtc;
|
|
proto.isUTC = isUtc;
|
|
proto.zoneAbbr = getZoneAbbr;
|
|
proto.zoneName = getZoneName;
|
|
proto.dates = deprecate(
|
|
'dates accessor is deprecated. Use date instead.',
|
|
getSetDayOfMonth
|
|
);
|
|
proto.months = deprecate(
|
|
'months accessor is deprecated. Use month instead',
|
|
getSetMonth
|
|
);
|
|
proto.years = deprecate(
|
|
'years accessor is deprecated. Use year instead',
|
|
getSetYear
|
|
);
|
|
proto.zone = deprecate(
|
|
'moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/',
|
|
getSetZone
|
|
);
|
|
proto.isDSTShifted = deprecate(
|
|
'isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information',
|
|
isDaylightSavingTimeShifted
|
|
);
|
|
|
|
function createUnix(input) {
|
|
return createLocal(input * 1000);
|
|
}
|
|
|
|
function createInZone() {
|
|
return createLocal.apply(null, arguments).parseZone();
|
|
}
|
|
|
|
function preParsePostFormat(string) {
|
|
return string;
|
|
}
|
|
|
|
var proto$1 = Locale.prototype;
|
|
|
|
proto$1.calendar = calendar;
|
|
proto$1.longDateFormat = longDateFormat;
|
|
proto$1.invalidDate = invalidDate;
|
|
proto$1.ordinal = ordinal;
|
|
proto$1.preparse = preParsePostFormat;
|
|
proto$1.postformat = preParsePostFormat;
|
|
proto$1.relativeTime = relativeTime;
|
|
proto$1.pastFuture = pastFuture;
|
|
proto$1.set = set;
|
|
proto$1.eras = localeEras;
|
|
proto$1.erasParse = localeErasParse;
|
|
proto$1.erasConvertYear = localeErasConvertYear;
|
|
proto$1.erasAbbrRegex = erasAbbrRegex;
|
|
proto$1.erasNameRegex = erasNameRegex;
|
|
proto$1.erasNarrowRegex = erasNarrowRegex;
|
|
|
|
proto$1.months = localeMonths;
|
|
proto$1.monthsShort = localeMonthsShort;
|
|
proto$1.monthsParse = localeMonthsParse;
|
|
proto$1.monthsRegex = monthsRegex;
|
|
proto$1.monthsShortRegex = monthsShortRegex;
|
|
proto$1.week = localeWeek;
|
|
proto$1.firstDayOfYear = localeFirstDayOfYear;
|
|
proto$1.firstDayOfWeek = localeFirstDayOfWeek;
|
|
|
|
proto$1.weekdays = localeWeekdays;
|
|
proto$1.weekdaysMin = localeWeekdaysMin;
|
|
proto$1.weekdaysShort = localeWeekdaysShort;
|
|
proto$1.weekdaysParse = localeWeekdaysParse;
|
|
|
|
proto$1.weekdaysRegex = weekdaysRegex;
|
|
proto$1.weekdaysShortRegex = weekdaysShortRegex;
|
|
proto$1.weekdaysMinRegex = weekdaysMinRegex;
|
|
|
|
proto$1.isPM = localeIsPM;
|
|
proto$1.meridiem = localeMeridiem;
|
|
|
|
function get$1(format, index, field, setter) {
|
|
var locale = getLocale(),
|
|
utc = createUTC().set(setter, index);
|
|
return locale[field](utc, format);
|
|
}
|
|
|
|
function listMonthsImpl(format, index, field) {
|
|
if (isNumber(format)) {
|
|
index = format;
|
|
format = undefined;
|
|
}
|
|
|
|
format = format || '';
|
|
|
|
if (index != null) {
|
|
return get$1(format, index, field, 'month');
|
|
}
|
|
|
|
var i,
|
|
out = [];
|
|
for (i = 0; i < 12; i++) {
|
|
out[i] = get$1(format, i, field, 'month');
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// ()
|
|
// (5)
|
|
// (fmt, 5)
|
|
// (fmt)
|
|
// (true)
|
|
// (true, 5)
|
|
// (true, fmt, 5)
|
|
// (true, fmt)
|
|
function listWeekdaysImpl(localeSorted, format, index, field) {
|
|
if (typeof localeSorted === 'boolean') {
|
|
if (isNumber(format)) {
|
|
index = format;
|
|
format = undefined;
|
|
}
|
|
|
|
format = format || '';
|
|
} else {
|
|
format = localeSorted;
|
|
index = format;
|
|
localeSorted = false;
|
|
|
|
if (isNumber(format)) {
|
|
index = format;
|
|
format = undefined;
|
|
}
|
|
|
|
format = format || '';
|
|
}
|
|
|
|
var locale = getLocale(),
|
|
shift = localeSorted ? locale._week.dow : 0,
|
|
i,
|
|
out = [];
|
|
|
|
if (index != null) {
|
|
return get$1(format, (index + shift) % 7, field, 'day');
|
|
}
|
|
|
|
for (i = 0; i < 7; i++) {
|
|
out[i] = get$1(format, (i + shift) % 7, field, 'day');
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function listMonths(format, index) {
|
|
return listMonthsImpl(format, index, 'months');
|
|
}
|
|
|
|
function listMonthsShort(format, index) {
|
|
return listMonthsImpl(format, index, 'monthsShort');
|
|
}
|
|
|
|
function listWeekdays(localeSorted, format, index) {
|
|
return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
|
|
}
|
|
|
|
function listWeekdaysShort(localeSorted, format, index) {
|
|
return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
|
|
}
|
|
|
|
function listWeekdaysMin(localeSorted, format, index) {
|
|
return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
|
|
}
|
|
|
|
getSetGlobalLocale('en', {
|
|
eras: [
|
|
{
|
|
since: '0001-01-01',
|
|
until: +Infinity,
|
|
offset: 1,
|
|
name: 'Anno Domini',
|
|
narrow: 'AD',
|
|
abbr: 'AD',
|
|
},
|
|
{
|
|
since: '0000-12-31',
|
|
until: -Infinity,
|
|
offset: 1,
|
|
name: 'Before Christ',
|
|
narrow: 'BC',
|
|
abbr: 'BC',
|
|
},
|
|
],
|
|
dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
|
|
ordinal: function (number) {
|
|
var b = number % 10,
|
|
output =
|
|
toInt((number % 100) / 10) === 1
|
|
? 'th'
|
|
: b === 1
|
|
? 'st'
|
|
: b === 2
|
|
? 'nd'
|
|
: b === 3
|
|
? 'rd'
|
|
: 'th';
|
|
return number + output;
|
|
},
|
|
});
|
|
|
|
// Side effect imports
|
|
|
|
hooks.lang = deprecate(
|
|
'moment.lang is deprecated. Use moment.locale instead.',
|
|
getSetGlobalLocale
|
|
);
|
|
hooks.langData = deprecate(
|
|
'moment.langData is deprecated. Use moment.localeData instead.',
|
|
getLocale
|
|
);
|
|
|
|
var mathAbs = Math.abs;
|
|
|
|
function abs() {
|
|
var data = this._data;
|
|
|
|
this._milliseconds = mathAbs(this._milliseconds);
|
|
this._days = mathAbs(this._days);
|
|
this._months = mathAbs(this._months);
|
|
|
|
data.milliseconds = mathAbs(data.milliseconds);
|
|
data.seconds = mathAbs(data.seconds);
|
|
data.minutes = mathAbs(data.minutes);
|
|
data.hours = mathAbs(data.hours);
|
|
data.months = mathAbs(data.months);
|
|
data.years = mathAbs(data.years);
|
|
|
|
return this;
|
|
}
|
|
|
|
function addSubtract$1(duration, input, value, direction) {
|
|
var other = createDuration(input, value);
|
|
|
|
duration._milliseconds += direction * other._milliseconds;
|
|
duration._days += direction * other._days;
|
|
duration._months += direction * other._months;
|
|
|
|
return duration._bubble();
|
|
}
|
|
|
|
// supports only 2.0-style add(1, 's') or add(duration)
|
|
function add$1(input, value) {
|
|
return addSubtract$1(this, input, value, 1);
|
|
}
|
|
|
|
// supports only 2.0-style subtract(1, 's') or subtract(duration)
|
|
function subtract$1(input, value) {
|
|
return addSubtract$1(this, input, value, -1);
|
|
}
|
|
|
|
function absCeil(number) {
|
|
if (number < 0) {
|
|
return Math.floor(number);
|
|
} else {
|
|
return Math.ceil(number);
|
|
}
|
|
}
|
|
|
|
function bubble() {
|
|
var milliseconds = this._milliseconds,
|
|
days = this._days,
|
|
months = this._months,
|
|
data = this._data,
|
|
seconds,
|
|
minutes,
|
|
hours,
|
|
years,
|
|
monthsFromDays;
|
|
|
|
// if we have a mix of positive and negative values, bubble down first
|
|
// check: https://github.com/moment/moment/issues/2166
|
|
if (
|
|
!(
|
|
(milliseconds >= 0 && days >= 0 && months >= 0) ||
|
|
(milliseconds <= 0 && days <= 0 && months <= 0)
|
|
)
|
|
) {
|
|
milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
|
|
days = 0;
|
|
months = 0;
|
|
}
|
|
|
|
// The following code bubbles up values, see the tests for
|
|
// examples of what that means.
|
|
data.milliseconds = milliseconds % 1000;
|
|
|
|
seconds = absFloor(milliseconds / 1000);
|
|
data.seconds = seconds % 60;
|
|
|
|
minutes = absFloor(seconds / 60);
|
|
data.minutes = minutes % 60;
|
|
|
|
hours = absFloor(minutes / 60);
|
|
data.hours = hours % 24;
|
|
|
|
days += absFloor(hours / 24);
|
|
|
|
// convert days to months
|
|
monthsFromDays = absFloor(daysToMonths(days));
|
|
months += monthsFromDays;
|
|
days -= absCeil(monthsToDays(monthsFromDays));
|
|
|
|
// 12 months -> 1 year
|
|
years = absFloor(months / 12);
|
|
months %= 12;
|
|
|
|
data.days = days;
|
|
data.months = months;
|
|
data.years = years;
|
|
|
|
return this;
|
|
}
|
|
|
|
function daysToMonths(days) {
|
|
// 400 years have 146097 days (taking into account leap year rules)
|
|
// 400 years have 12 months === 4800
|
|
return (days * 4800) / 146097;
|
|
}
|
|
|
|
function monthsToDays(months) {
|
|
// the reverse of daysToMonths
|
|
return (months * 146097) / 4800;
|
|
}
|
|
|
|
function as(units) {
|
|
if (!this.isValid()) {
|
|
return NaN;
|
|
}
|
|
var days,
|
|
months,
|
|
milliseconds = this._milliseconds;
|
|
|
|
units = normalizeUnits(units);
|
|
|
|
if (units === 'month' || units === 'quarter' || units === 'year') {
|
|
days = this._days + milliseconds / 864e5;
|
|
months = this._months + daysToMonths(days);
|
|
switch (units) {
|
|
case 'month':
|
|
return months;
|
|
case 'quarter':
|
|
return months / 3;
|
|
case 'year':
|
|
return months / 12;
|
|
}
|
|
} else {
|
|
// handle milliseconds separately because of floating point math errors (issue #1867)
|
|
days = this._days + Math.round(monthsToDays(this._months));
|
|
switch (units) {
|
|
case 'week':
|
|
return days / 7 + milliseconds / 6048e5;
|
|
case 'day':
|
|
return days + milliseconds / 864e5;
|
|
case 'hour':
|
|
return days * 24 + milliseconds / 36e5;
|
|
case 'minute':
|
|
return days * 1440 + milliseconds / 6e4;
|
|
case 'second':
|
|
return days * 86400 + milliseconds / 1000;
|
|
// Math.floor prevents floating point math errors here
|
|
case 'millisecond':
|
|
return Math.floor(days * 864e5) + milliseconds;
|
|
default:
|
|
throw new Error('Unknown unit ' + units);
|
|
}
|
|
}
|
|
}
|
|
|
|
function makeAs(alias) {
|
|
return function () {
|
|
return this.as(alias);
|
|
};
|
|
}
|
|
|
|
var asMilliseconds = makeAs('ms'),
|
|
asSeconds = makeAs('s'),
|
|
asMinutes = makeAs('m'),
|
|
asHours = makeAs('h'),
|
|
asDays = makeAs('d'),
|
|
asWeeks = makeAs('w'),
|
|
asMonths = makeAs('M'),
|
|
asQuarters = makeAs('Q'),
|
|
asYears = makeAs('y'),
|
|
valueOf$1 = asMilliseconds;
|
|
|
|
function clone$1() {
|
|
return createDuration(this);
|
|
}
|
|
|
|
function get$2(units) {
|
|
units = normalizeUnits(units);
|
|
return this.isValid() ? this[units + 's']() : NaN;
|
|
}
|
|
|
|
function makeGetter(name) {
|
|
return function () {
|
|
return this.isValid() ? this._data[name] : NaN;
|
|
};
|
|
}
|
|
|
|
var milliseconds = makeGetter('milliseconds'),
|
|
seconds = makeGetter('seconds'),
|
|
minutes = makeGetter('minutes'),
|
|
hours = makeGetter('hours'),
|
|
days = makeGetter('days'),
|
|
months = makeGetter('months'),
|
|
years = makeGetter('years');
|
|
|
|
function weeks() {
|
|
return absFloor(this.days() / 7);
|
|
}
|
|
|
|
var round = Math.round,
|
|
thresholds = {
|
|
ss: 44, // a few seconds to seconds
|
|
s: 45, // seconds to minute
|
|
m: 45, // minutes to hour
|
|
h: 22, // hours to day
|
|
d: 26, // days to month/week
|
|
w: null, // weeks to month
|
|
M: 11, // months to year
|
|
};
|
|
|
|
// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
|
|
function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
|
|
return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
|
|
}
|
|
|
|
function relativeTime$1(posNegDuration, withoutSuffix, thresholds, locale) {
|
|
var duration = createDuration(posNegDuration).abs(),
|
|
seconds = round(duration.as('s')),
|
|
minutes = round(duration.as('m')),
|
|
hours = round(duration.as('h')),
|
|
days = round(duration.as('d')),
|
|
months = round(duration.as('M')),
|
|
weeks = round(duration.as('w')),
|
|
years = round(duration.as('y')),
|
|
a =
|
|
(seconds <= thresholds.ss && ['s', seconds]) ||
|
|
(seconds < thresholds.s && ['ss', seconds]) ||
|
|
(minutes <= 1 && ['m']) ||
|
|
(minutes < thresholds.m && ['mm', minutes]) ||
|
|
(hours <= 1 && ['h']) ||
|
|
(hours < thresholds.h && ['hh', hours]) ||
|
|
(days <= 1 && ['d']) ||
|
|
(days < thresholds.d && ['dd', days]);
|
|
|
|
if (thresholds.w != null) {
|
|
a =
|
|
a ||
|
|
(weeks <= 1 && ['w']) ||
|
|
(weeks < thresholds.w && ['ww', weeks]);
|
|
}
|
|
a = a ||
|
|
(months <= 1 && ['M']) ||
|
|
(months < thresholds.M && ['MM', months]) ||
|
|
(years <= 1 && ['y']) || ['yy', years];
|
|
|
|
a[2] = withoutSuffix;
|
|
a[3] = +posNegDuration > 0;
|
|
a[4] = locale;
|
|
return substituteTimeAgo.apply(null, a);
|
|
}
|
|
|
|
// This function allows you to set the rounding function for relative time strings
|
|
function getSetRelativeTimeRounding(roundingFunction) {
|
|
if (roundingFunction === undefined) {
|
|
return round;
|
|
}
|
|
if (typeof roundingFunction === 'function') {
|
|
round = roundingFunction;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// This function allows you to set a threshold for relative time strings
|
|
function getSetRelativeTimeThreshold(threshold, limit) {
|
|
if (thresholds[threshold] === undefined) {
|
|
return false;
|
|
}
|
|
if (limit === undefined) {
|
|
return thresholds[threshold];
|
|
}
|
|
thresholds[threshold] = limit;
|
|
if (threshold === 's') {
|
|
thresholds.ss = limit - 1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function humanize(argWithSuffix, argThresholds) {
|
|
if (!this.isValid()) {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
|
|
var withSuffix = false,
|
|
th = thresholds,
|
|
locale,
|
|
output;
|
|
|
|
if (typeof argWithSuffix === 'object') {
|
|
argThresholds = argWithSuffix;
|
|
argWithSuffix = false;
|
|
}
|
|
if (typeof argWithSuffix === 'boolean') {
|
|
withSuffix = argWithSuffix;
|
|
}
|
|
if (typeof argThresholds === 'object') {
|
|
th = Object.assign({}, thresholds, argThresholds);
|
|
if (argThresholds.s != null && argThresholds.ss == null) {
|
|
th.ss = argThresholds.s - 1;
|
|
}
|
|
}
|
|
|
|
locale = this.localeData();
|
|
output = relativeTime$1(this, !withSuffix, th, locale);
|
|
|
|
if (withSuffix) {
|
|
output = locale.pastFuture(+this, output);
|
|
}
|
|
|
|
return locale.postformat(output);
|
|
}
|
|
|
|
var abs$1 = Math.abs;
|
|
|
|
function sign(x) {
|
|
return (x > 0) - (x < 0) || +x;
|
|
}
|
|
|
|
function toISOString$1() {
|
|
// for ISO strings we do not use the normal bubbling rules:
|
|
// * milliseconds bubble up until they become hours
|
|
// * days do not bubble at all
|
|
// * months bubble up until they become years
|
|
// This is because there is no context-free conversion between hours and days
|
|
// (think of clock changes)
|
|
// and also not between days and months (28-31 days per month)
|
|
if (!this.isValid()) {
|
|
return this.localeData().invalidDate();
|
|
}
|
|
|
|
var seconds = abs$1(this._milliseconds) / 1000,
|
|
days = abs$1(this._days),
|
|
months = abs$1(this._months),
|
|
minutes,
|
|
hours,
|
|
years,
|
|
s,
|
|
total = this.asSeconds(),
|
|
totalSign,
|
|
ymSign,
|
|
daysSign,
|
|
hmsSign;
|
|
|
|
if (!total) {
|
|
// this is the same as C#'s (Noda) and python (isodate)...
|
|
// but not other JS (goog.date)
|
|
return 'P0D';
|
|
}
|
|
|
|
// 3600 seconds -> 60 minutes -> 1 hour
|
|
minutes = absFloor(seconds / 60);
|
|
hours = absFloor(minutes / 60);
|
|
seconds %= 60;
|
|
minutes %= 60;
|
|
|
|
// 12 months -> 1 year
|
|
years = absFloor(months / 12);
|
|
months %= 12;
|
|
|
|
// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
|
|
s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
|
|
|
|
totalSign = total < 0 ? '-' : '';
|
|
ymSign = sign(this._months) !== sign(total) ? '-' : '';
|
|
daysSign = sign(this._days) !== sign(total) ? '-' : '';
|
|
hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
|
|
|
|
return (
|
|
totalSign +
|
|
'P' +
|
|
(years ? ymSign + years + 'Y' : '') +
|
|
(months ? ymSign + months + 'M' : '') +
|
|
(days ? daysSign + days + 'D' : '') +
|
|
(hours || minutes || seconds ? 'T' : '') +
|
|
(hours ? hmsSign + hours + 'H' : '') +
|
|
(minutes ? hmsSign + minutes + 'M' : '') +
|
|
(seconds ? hmsSign + s + 'S' : '')
|
|
);
|
|
}
|
|
|
|
var proto$2 = Duration.prototype;
|
|
|
|
proto$2.isValid = isValid$1;
|
|
proto$2.abs = abs;
|
|
proto$2.add = add$1;
|
|
proto$2.subtract = subtract$1;
|
|
proto$2.as = as;
|
|
proto$2.asMilliseconds = asMilliseconds;
|
|
proto$2.asSeconds = asSeconds;
|
|
proto$2.asMinutes = asMinutes;
|
|
proto$2.asHours = asHours;
|
|
proto$2.asDays = asDays;
|
|
proto$2.asWeeks = asWeeks;
|
|
proto$2.asMonths = asMonths;
|
|
proto$2.asQuarters = asQuarters;
|
|
proto$2.asYears = asYears;
|
|
proto$2.valueOf = valueOf$1;
|
|
proto$2._bubble = bubble;
|
|
proto$2.clone = clone$1;
|
|
proto$2.get = get$2;
|
|
proto$2.milliseconds = milliseconds;
|
|
proto$2.seconds = seconds;
|
|
proto$2.minutes = minutes;
|
|
proto$2.hours = hours;
|
|
proto$2.days = days;
|
|
proto$2.weeks = weeks;
|
|
proto$2.months = months;
|
|
proto$2.years = years;
|
|
proto$2.humanize = humanize;
|
|
proto$2.toISOString = toISOString$1;
|
|
proto$2.toString = toISOString$1;
|
|
proto$2.toJSON = toISOString$1;
|
|
proto$2.locale = locale;
|
|
proto$2.localeData = localeData;
|
|
|
|
proto$2.toIsoString = deprecate(
|
|
'toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',
|
|
toISOString$1
|
|
);
|
|
proto$2.lang = lang;
|
|
|
|
// FORMATTING
|
|
|
|
addFormatToken('X', 0, 0, 'unix');
|
|
addFormatToken('x', 0, 0, 'valueOf');
|
|
|
|
// PARSING
|
|
|
|
addRegexToken('x', matchSigned);
|
|
addRegexToken('X', matchTimestamp);
|
|
addParseToken('X', function (input, array, config) {
|
|
config._d = new Date(parseFloat(input) * 1000);
|
|
});
|
|
addParseToken('x', function (input, array, config) {
|
|
config._d = new Date(toInt(input));
|
|
});
|
|
|
|
//! moment.js
|
|
|
|
hooks.version = '2.30.1';
|
|
|
|
setHookCallback(createLocal);
|
|
|
|
hooks.fn = proto;
|
|
hooks.min = min;
|
|
hooks.max = max;
|
|
hooks.now = now;
|
|
hooks.utc = createUTC;
|
|
hooks.unix = createUnix;
|
|
hooks.months = listMonths;
|
|
hooks.isDate = isDate;
|
|
hooks.locale = getSetGlobalLocale;
|
|
hooks.invalid = createInvalid;
|
|
hooks.duration = createDuration;
|
|
hooks.isMoment = isMoment;
|
|
hooks.weekdays = listWeekdays;
|
|
hooks.parseZone = createInZone;
|
|
hooks.localeData = getLocale;
|
|
hooks.isDuration = isDuration;
|
|
hooks.monthsShort = listMonthsShort;
|
|
hooks.weekdaysMin = listWeekdaysMin;
|
|
hooks.defineLocale = defineLocale;
|
|
hooks.updateLocale = updateLocale;
|
|
hooks.locales = listLocales;
|
|
hooks.weekdaysShort = listWeekdaysShort;
|
|
hooks.normalizeUnits = normalizeUnits;
|
|
hooks.relativeTimeRounding = getSetRelativeTimeRounding;
|
|
hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
|
|
hooks.calendarFormat = getCalendarFormat;
|
|
hooks.prototype = proto;
|
|
|
|
// currently HTML5 input type only supports 24-hour formats
|
|
hooks.HTML5_FMT = {
|
|
DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // <input type="datetime-local" />
|
|
DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // <input type="datetime-local" step="1" />
|
|
DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // <input type="datetime-local" step="0.001" />
|
|
DATE: 'YYYY-MM-DD', // <input type="date" />
|
|
TIME: 'HH:mm', // <input type="time" />
|
|
TIME_SECONDS: 'HH:mm:ss', // <input type="time" step="1" />
|
|
TIME_MS: 'HH:mm:ss.SSS', // <input type="time" step="0.001" />
|
|
WEEK: 'GGGG-[W]WW', // <input type="week" />
|
|
MONTH: 'YYYY-MM', // <input type="month" />
|
|
};
|
|
|
|
return hooks;
|
|
|
|
})));
|
|
} (moment$1, moment$1.exports));
|
|
|
|
var momentExports = moment$1.exports;
|
|
var moment = /*@__PURE__*/getDefaultExportFromCjs(momentExports);
|
|
|
|
function imageTagProcessor(app, noteFile, settings, defaultdir) {
|
|
const unique = Math.random().toString(16).slice(2);
|
|
function processImageTag(match, anchor, link, caption, imgsize) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
logError("processImageTag: " + match);
|
|
if (!isUrl(link)) {
|
|
return match;
|
|
}
|
|
try {
|
|
var lock = new AsyncLock();
|
|
let fpath;
|
|
let fileData;
|
|
const opsys = process.platform;
|
|
const mediaDir = yield getMDir(app.app, noteFile, settings, defaultdir, unique);
|
|
yield app.ensureFolderExists(mediaDir);
|
|
const protocol = link.slice(0, 5);
|
|
if (protocol == "data:") {
|
|
logError("ReadBase64: \r\n" + fpath, false);
|
|
fileData = yield base64ToBuff(link);
|
|
}
|
|
else if (protocol == "file:") {
|
|
logError("Readlocal: \r\n" + fpath, false);
|
|
if (SUPPORTED_OS.win.includes(opsys)) {
|
|
fpath = link.replace("file:///", "");
|
|
}
|
|
else if (SUPPORTED_OS.unix.includes(opsys)) {
|
|
fpath = link.replace("file://", "");
|
|
}
|
|
else {
|
|
fpath = link.replace("file://", "");
|
|
}
|
|
fileData = yield readFromDisk(fpath);
|
|
if (fileData === null) {
|
|
fileData = yield readFromDisk(decodeURI(fpath));
|
|
}
|
|
}
|
|
else {
|
|
//Try to download several times
|
|
let trycount = 0;
|
|
while (trycount < settings.tryCount) {
|
|
fileData = yield downloadImage(link);
|
|
logError("\r\n\nDownloading (try): " + trycount + "\r\n\n");
|
|
if (fileData !== null) {
|
|
break;
|
|
}
|
|
trycount++;
|
|
}
|
|
}
|
|
if (fileData === null) {
|
|
logError("Cannot get an attachment content!", false);
|
|
return null;
|
|
}
|
|
if (Math.round(fileData.byteLength / 1024) < settings.filesizeLimit) {
|
|
logError("Lower limit of the file size!", false);
|
|
return null;
|
|
}
|
|
try {
|
|
const { fileName, needWrite } = yield lock.acquire(match, function () {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const parsedUrl = new url.URL(link);
|
|
let fileExt = yield getFileExt(fileData, parsedUrl.pathname);
|
|
if (fileExt == "png" && settings.PngToJpeg) {
|
|
let compType = "image/jpeg";
|
|
if (settings.ImgCompressionType == "image/webp") {
|
|
compType = "image/webp";
|
|
}
|
|
const blob = new Blob([new Uint8Array(fileData)]);
|
|
fileData = yield blobToJpegArrayBuffer(blob, settings.JpegQuality * 0.01, compType);
|
|
logError("arbuf: ");
|
|
logError(fileData);
|
|
}
|
|
const { fileName, needWrite } = yield chooseFileName(app.app.vault.adapter, mediaDir, link, fileData, settings);
|
|
return { fileName, needWrite };
|
|
});
|
|
});
|
|
if (needWrite && fileName) {
|
|
yield app.app.vault.createBinary(fileName, fileData);
|
|
}
|
|
if (fileName) {
|
|
let shortName = "";
|
|
const rdir = yield getRDir(noteFile, settings, fileName, link);
|
|
let pathWiki = rdir[0];
|
|
let pathMd = rdir[1];
|
|
if (settings.addNameOfFile && protocol == "file:") {
|
|
if (!app.app.vault.getConfig("useMarkdownLinks")) {
|
|
shortName = "\r\n[[" +
|
|
fileName +
|
|
"\|" +
|
|
rdir[2]["lnkurid"] + "]]\r\n";
|
|
}
|
|
else {
|
|
shortName = "\r\n[" +
|
|
rdir[2]["lnkurid"] +
|
|
"](" +
|
|
rdir[2]["pathuri"] +
|
|
")\r\n";
|
|
}
|
|
}
|
|
if (!app.app.vault.getConfig("useMarkdownLinks")) {
|
|
// image caption
|
|
(!settings.useCaptions || !caption.length) ? caption = "" : caption = "\|" + caption;
|
|
// image size has higher priority
|
|
(!settings.useCaptions || !imgsize.length) ? caption = "" : caption = "\|" + imgsize;
|
|
return [match, `![[${pathWiki}${caption}]]`, `${shortName}`];
|
|
}
|
|
else {
|
|
(!settings.useCaptions || !caption.length) ? caption = "" : caption = " " + caption;
|
|
return [match, ``, `${shortName}`];
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
catch (error) {
|
|
if (error.message === "File already exists.") {
|
|
}
|
|
else {
|
|
throw error;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
catch (error) {
|
|
logError("Image processing failed: " + error, false);
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
return processImageTag;
|
|
}
|
|
function getRDir(noteFile, settings, fileName, link = undefined) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
let pathWiki = "";
|
|
let pathMd = "";
|
|
const notePath = normalizePath(noteFile.parent.path);
|
|
const parsedPath = path__default["default"].parse(normalizePath(fileName));
|
|
const parsedPathE = {
|
|
parentd: path__default["default"].basename(parsedPath["dir"]),
|
|
basen: (parsedPath["name"] + parsedPath["ext"]),
|
|
lnkurid: path__default["default"].basename(decodeURI(link)),
|
|
pathuri: encodeURI(normalizePath(fileName))
|
|
};
|
|
switch (settings.pathInTags) {
|
|
case "baseFileName":
|
|
pathWiki = pathMd = parsedPathE["basen"];
|
|
break;
|
|
case "onlyRelative":
|
|
pathWiki = pathJoin([path__default["default"].relative(path__default["default"].sep + notePath, path__default["default"].sep + parsedPath["dir"]), parsedPathE["basen"]]);
|
|
pathMd = encodeURI(pathWiki);
|
|
break;
|
|
case "fullDirPath":
|
|
pathWiki = fileName.replace(/\\/g, "/");
|
|
pathMd = parsedPathE["pathuri"];
|
|
break;
|
|
default:
|
|
pathWiki = fileName;
|
|
pathMd = parsedPathE["pathuri"];
|
|
}
|
|
return [pathWiki, pathMd, parsedPathE];
|
|
});
|
|
}
|
|
function getMDir(app, noteFile, settings, defaultdir = false, unique = "") {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
noteFile.parent.path;
|
|
const current_date = moment().format(settings.DateFormat);
|
|
const obsmediadir = app.vault.getConfig("attachmentFolderPath");
|
|
const mediadir = settings.mediaRootDir;
|
|
var attdir = settings.saveAttE;
|
|
if (defaultdir) {
|
|
attdir = "";
|
|
}
|
|
let root = "/";
|
|
switch (attdir) {
|
|
case 'inFolderBelow':
|
|
root = mediadir
|
|
.replace("${notename}", noteFile.basename)
|
|
.replace("${unique}", unique)
|
|
.replace("${date}", current_date);
|
|
break;
|
|
case 'nextToNoteS':
|
|
root = (pathJoin([noteFile.parent.path, mediadir]))
|
|
.replace("${notename}", noteFile.basename)
|
|
.replace("${unique}", unique)
|
|
.replace("${date}", current_date);
|
|
break;
|
|
default:
|
|
if (obsmediadir === '/') {
|
|
root = obsmediadir;
|
|
}
|
|
else if (obsmediadir === './') {
|
|
root = pathJoin([noteFile.parent.path]);
|
|
}
|
|
else if (obsmediadir.match(/\.\/.+/g) !== null) {
|
|
root = pathJoin([noteFile.parent.path, obsmediadir.replace('\.\/', '')]);
|
|
}
|
|
else {
|
|
root = normalizePath(obsmediadir);
|
|
}
|
|
}
|
|
return trimAny(root, ["/", "\\"]);
|
|
});
|
|
}
|
|
function chooseFileName(adapter, dir, link, contentData, settings) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const parsedUrl = new url.URL(link);
|
|
const ignoredExt = settings.ignoredExt.split("|");
|
|
let fileExt = yield getFileExt(contentData, parsedUrl.pathname);
|
|
logError("file: " + link + " content: " + contentData + " file ext: " + fileExt, false);
|
|
if (fileExt == "unknown" && !settings.downUnknown) {
|
|
return { fileName: "", needWrite: false };
|
|
}
|
|
if (ignoredExt.includes(fileExt)) {
|
|
return { fileName: "", needWrite: false };
|
|
}
|
|
const baseName = md5Sig(contentData);
|
|
let needWrite = true;
|
|
let fileName = "";
|
|
const suggestedName = pathJoin([dir, cleanFileName(`${baseName}` + `.${fileExt}`)]);
|
|
if (yield adapter.exists(suggestedName, false)) {
|
|
const fileData = yield adapter.readBinary(suggestedName);
|
|
const existing_file_md5 = md5Sig(fileData);
|
|
if (existing_file_md5 === baseName) {
|
|
fileName = suggestedName;
|
|
needWrite = false;
|
|
}
|
|
else {
|
|
fileName = pathJoin([dir, cleanFileName(Math.random().toString(9).slice(2) + `.${fileExt}`)]);
|
|
}
|
|
}
|
|
else {
|
|
fileName = suggestedName;
|
|
}
|
|
logError("File name: " + fileName, false);
|
|
if (!fileName) {
|
|
throw new Error("Failed to generate file name for media file.");
|
|
}
|
|
//linkHashes.ensureHashGenerated(link, contentData);
|
|
return { fileName, needWrite };
|
|
});
|
|
}
|
|
|
|
// Queue that keep only unique values and counts attempts
|
|
class UniqueQueue {
|
|
constructor() {
|
|
this.queue = new Array();
|
|
}
|
|
push(value, attempts) {
|
|
if (attempts < 1) {
|
|
console.error("Triyng to enqueue item with attempts < 1");
|
|
return;
|
|
}
|
|
this.remove(value);
|
|
this.queue.push({ value, attempts });
|
|
}
|
|
remove(value) {
|
|
this.queue = this.queue.filter((item) => item.value !== value);
|
|
}
|
|
iterationQueue() {
|
|
const extractIteration = (prev, curr) => {
|
|
prev.iteration.push(curr.value);
|
|
if (curr.attempts > 1) {
|
|
prev.queue.push(curr.value, curr.attempts - 1);
|
|
}
|
|
return prev;
|
|
};
|
|
const { queue, iteration } = this.queue.reduce(extractIteration, {
|
|
queue: new UniqueQueue(),
|
|
iteration: [],
|
|
});
|
|
this.queue = queue.queue;
|
|
return iteration;
|
|
}
|
|
}
|
|
|
|
class ModalW1 extends obsidian.Modal {
|
|
constructor(app) {
|
|
super(app);
|
|
this.messg = "";
|
|
this.callbackFunc = null;
|
|
}
|
|
onOpen() {
|
|
let { contentEl, titleEl } = this;
|
|
titleEl.setText(APP_TITLE);
|
|
contentEl.createDiv({
|
|
text: this.messg
|
|
});
|
|
contentEl.createEl("button", {
|
|
cls: ["mod-cta"],
|
|
text: "Cancel"
|
|
}).addEventListener("click", () => __awaiter(this, void 0, void 0, function* () {
|
|
this.close();
|
|
}));
|
|
contentEl.createEl("button", {
|
|
cls: ["mod-cta"],
|
|
text: "Confirm"
|
|
}).addEventListener("click", () => __awaiter(this, void 0, void 0, function* () {
|
|
this.close();
|
|
if (this.callbackFunc) {
|
|
this.callbackFunc();
|
|
}
|
|
}));
|
|
}
|
|
onClose() {
|
|
let { contentEl } = this;
|
|
contentEl.empty();
|
|
}
|
|
}
|
|
|
|
require('fs').promises;
|
|
//import { count, log } from "console"
|
|
class LocalImagesPlugin extends obsidian.Plugin {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.modifiedQueue = new UniqueQueue();
|
|
this.intervalId = 0;
|
|
this.newfCreated = [];
|
|
this.noteModified = [];
|
|
this.newfMoveReq = true;
|
|
this.newfCreatedByDownloader = [];
|
|
// using arrow syntax for callbacks to correctly pass this context
|
|
this.processActivePage = (defaultdir = false) => () => __awaiter(this, void 0, void 0, function* () {
|
|
logError("processActivePage");
|
|
try {
|
|
const activeFile = this.getCurrentNote();
|
|
yield this.processPage(activeFile, defaultdir);
|
|
}
|
|
catch (e) {
|
|
showBalloon(`Please select a note or click inside selected note in canvas.`, this.settings.showNotifications);
|
|
return;
|
|
}
|
|
});
|
|
this.processAllPages = () => __awaiter(this, void 0, void 0, function* () {
|
|
const files = this.app.vault.getMarkdownFiles();
|
|
const pagesCount = files.length;
|
|
const notice = this.settings.showNotifications
|
|
? new obsidian.Notice(APP_TITLE + `\nStart processing. Total ${pagesCount} pages. `, TIMEOUT_LIKE_INFINITY)
|
|
: null;
|
|
for (const [index, file] of files.entries()) {
|
|
if (this.ExemplaryOfMD(file.path)) {
|
|
if (notice) {
|
|
//setMessage() is undeclared but factically existing, so ignore the TS error //@ts-expect-error
|
|
notice.setMessage(APP_TITLE + `\nProcessing \n"${file.path}" \nPage ${index} of ${pagesCount}`);
|
|
}
|
|
yield this.processPage(file);
|
|
}
|
|
}
|
|
if (notice) {
|
|
// dum @ts-expect-error
|
|
notice.setMessage(APP_TITLE + `\n${pagesCount} pages were processed.`);
|
|
setTimeout(() => {
|
|
notice.hide();
|
|
}, NOTICE_TIMEOUT);
|
|
}
|
|
});
|
|
this.removeOrphans = (type = undefined, filesToRemove = undefined, noteFile = undefined) => () => __awaiter(this, void 0, void 0, function* () {
|
|
var _a, _b, _c, _d, _e;
|
|
const obsmediadir = app.vault.getConfig("attachmentFolderPath");
|
|
const allFiles = this.app.vault.getFiles();
|
|
let oldRootdir = this.settings.mediaRootDir;
|
|
if (type == "plugin") {
|
|
let orphanedAttachments = [];
|
|
let allAttachmentsLinks = [];
|
|
if (this.settings.saveAttE != "nextToNoteS" ||
|
|
!path__default["default"].basename(oldRootdir).endsWith("${notename}") ||
|
|
oldRootdir.includes("${date}")) {
|
|
showBalloon("This command requires the settings 'Next to note in the folder specified below' and pattern '${notename}' at the end to be enabled, also the path cannot contain ${date} pattern.\nPlease, change settings first!\r\n", this.settings.showNotifications);
|
|
return;
|
|
}
|
|
if (!noteFile) {
|
|
noteFile = this.getCurrentNote();
|
|
if (!noteFile) {
|
|
showBalloon("Please, select a note or click inside a note in canvas!", this.settings.showNotifications);
|
|
return;
|
|
}
|
|
}
|
|
if (this.ExemplaryOfMD(noteFile.path)) {
|
|
oldRootdir = oldRootdir.replace("${notename}", (_a = path__default["default"].parse(noteFile.path)) === null || _a === void 0 ? void 0 : _a.name);
|
|
oldRootdir = trimAny(pathJoin([(_b = path__default["default"].parse(noteFile.path)) === null || _b === void 0 ? void 0 : _b.dir, oldRootdir]), ["\/"]);
|
|
if (!(yield this.app.vault.exists(oldRootdir))) {
|
|
showBalloon("The attachment folder " + oldRootdir + " does not exist!", this.settings.showNotifications);
|
|
return;
|
|
}
|
|
const allAttachments = yield ((_c = this.app.vault.getAbstractFileByPath(oldRootdir)) === null || _c === void 0 ? void 0 : _c.children);
|
|
const metaCache = this.app.metadataCache.getFileCache(noteFile);
|
|
const embeds = metaCache === null || metaCache === void 0 ? void 0 : metaCache.embeds;
|
|
const links = metaCache === null || metaCache === void 0 ? void 0 : metaCache.links;
|
|
if (embeds) {
|
|
for (const embed of embeds) {
|
|
allAttachmentsLinks.push(path__default["default"].basename(embed.link));
|
|
}
|
|
}
|
|
if (links) {
|
|
for (const link of links) {
|
|
allAttachmentsLinks.push(path__default["default"].basename(link.link));
|
|
}
|
|
}
|
|
if (allAttachments) {
|
|
for (const attach of allAttachments) {
|
|
if (!allAttachmentsLinks.includes(attach.name) && attach.children == undefined) {
|
|
logError("orph: " + attach.basename);
|
|
orphanedAttachments.push(attach);
|
|
}
|
|
}
|
|
}
|
|
if (orphanedAttachments.length > 0) {
|
|
const mod = new ModalW1(this.app);
|
|
mod.messg = "Confirm remove " + orphanedAttachments.length + " orphan(s) from '" + oldRootdir + "'\r\n\r\n ";
|
|
mod.plugin = this;
|
|
mod.callbackFunc = this.removeOrphans("execremove", orphanedAttachments);
|
|
mod.open();
|
|
}
|
|
else {
|
|
showBalloon("No orphaned files found!", this.settings.showNotifications);
|
|
}
|
|
}
|
|
}
|
|
if (type == "obsidian") {
|
|
if (obsmediadir.slice(0, 2) == "./" || obsmediadir == "/") {
|
|
showBalloon("This command cannot run on vault's root or on subfolder next to note!\nPlease, change settings first!\r\n", this.settings.showNotifications);
|
|
return;
|
|
}
|
|
const allAttachments = (_d = this.app.vault.getAbstractFileByPath(obsmediadir)) === null || _d === void 0 ? void 0 : _d.children;
|
|
let orphanedAttachments = [];
|
|
let allAttachmentsLinks = [];
|
|
if (allFiles) {
|
|
for (const file of allFiles) {
|
|
//Fix for canvas files
|
|
if (file !== null && this.ExemplaryOfCANVAS(file.path)) {
|
|
logError(file);
|
|
logError(this.app.metadataCache.getCache(file.path));
|
|
let canvasData;
|
|
try {
|
|
canvasData = JSON.parse(yield app.vault.cachedRead(file));
|
|
}
|
|
catch (e) {
|
|
logError("Parse canvas data error");
|
|
continue;
|
|
}
|
|
if (canvasData.nodes && canvasData.nodes.length > 0) {
|
|
for (const node of canvasData.nodes) {
|
|
logError(node);
|
|
if (node.type === "file") {
|
|
logError("file json");
|
|
allAttachmentsLinks.push(path__default["default"].basename(node.file));
|
|
}
|
|
else if (node.type == "text") {
|
|
logError("text json");
|
|
//https://github.com/Fevol/obsidian-typings
|
|
//Undocumented API may be altered in the future
|
|
const AllNodeLinks = (_e = (yield this.app.internalPlugins.plugins.canvas.instance.index.parseText(node.text))) === null || _e === void 0 ? void 0 : _e.links;
|
|
logError(AllNodeLinks);
|
|
if (AllNodeLinks === undefined) {
|
|
continue;
|
|
}
|
|
for (const Nodelink of AllNodeLinks) {
|
|
allAttachmentsLinks.push(path__default["default"].basename(Nodelink.link));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (file !== null && this.ExemplaryOfMD(file.path)) {
|
|
const metaCache = this.app.metadataCache.getCache(file.path);
|
|
const embeds = metaCache === null || metaCache === void 0 ? void 0 : metaCache.embeds;
|
|
const links = metaCache === null || metaCache === void 0 ? void 0 : metaCache.links;
|
|
logError(embeds);
|
|
logError(links);
|
|
if (embeds) {
|
|
for (const embed of embeds) {
|
|
allAttachmentsLinks.push(path__default["default"].basename(embed.link));
|
|
}
|
|
}
|
|
if (links) {
|
|
for (const link of links) {
|
|
allAttachmentsLinks.push(path__default["default"].basename(link.link));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const attach of allAttachments) {
|
|
if (!allAttachmentsLinks.includes(attach.name) && attach.children == undefined) {
|
|
logError(allAttachmentsLinks);
|
|
logError(attach.name);
|
|
logError("orph: " + attach.name);
|
|
orphanedAttachments.push(attach);
|
|
}
|
|
}
|
|
}
|
|
logError("Orphaned: ");
|
|
logError(orphanedAttachments, true);
|
|
if (orphanedAttachments.length > 0) {
|
|
const mod = new ModalW1(this.app);
|
|
mod.messg = "Confirm remove " + orphanedAttachments.length + " orphan(s) from '" + obsmediadir + " '\r\n \
|
|
NOTE: Be careful when running this command on Obsidian attachments folder, since some html-linked files may also be moved.\r\n ";
|
|
mod.plugin = this;
|
|
mod.callbackFunc = this.removeOrphans("execremove", orphanedAttachments);
|
|
mod.open();
|
|
}
|
|
else {
|
|
showBalloon("No orphaned files found!", this.settings.showNotifications);
|
|
}
|
|
}
|
|
if (type == "execremove") {
|
|
const useSysTrash = (this.app.vault.getConfig("trashOption") === "system");
|
|
const remcompl = this.settings.removeOrphansCompl;
|
|
let msg = "";
|
|
if (filesToRemove) {
|
|
filesToRemove.forEach((el) => {
|
|
if (remcompl) {
|
|
msg = "were deleted completely.";
|
|
this.app.vault.delete(el, true);
|
|
}
|
|
else {
|
|
if (useSysTrash) {
|
|
msg = "were moved to the system garbage can.";
|
|
}
|
|
else {
|
|
msg = "were moved to the Obsidian garbage can.";
|
|
}
|
|
this.app.vault.trash(el, useSysTrash);
|
|
}
|
|
});
|
|
}
|
|
showBalloon(filesToRemove.length + " file(s) " + msg, this.settings.showNotifications);
|
|
}
|
|
});
|
|
this.openProcessAllModal = () => {
|
|
const mod = new ModalW1(this.app);
|
|
mod.messg = "Confirm processing all pages.\r\n ";
|
|
mod.plugin = this;
|
|
mod.callbackFunc = this.processAllPages;
|
|
mod.open();
|
|
};
|
|
this.processMdFilesOnTimer = () => __awaiter(this, void 0, void 0, function* () {
|
|
var _f;
|
|
const th = this;
|
|
function onRet() {
|
|
th.newfCreated = [];
|
|
th.newfCreatedByDownloader = [];
|
|
th.noteModified = [];
|
|
th.newfMoveReq = false;
|
|
window.clearInterval(th.newfProcInt);
|
|
th.newfProcInt = 0;
|
|
}
|
|
logError("func processMdFilesOnTimer:\r\n");
|
|
logError(this.noteModified, true);
|
|
try {
|
|
window.clearInterval(this.newfProcInt);
|
|
this.newfProcInt = 0;
|
|
this.newfMoveReq = false;
|
|
let itemcount = 0;
|
|
const useMdLinks = this.app.vault.getConfig("useMarkdownLinks");
|
|
for (let note of this.noteModified) {
|
|
const metaCache = this.app.metadataCache.getFileCache(note);
|
|
let filedata = yield this.app.vault.cachedRead(note);
|
|
let pr = false;
|
|
for (const reg_p of MD_SEARCH_PATTERN) {
|
|
if (reg_p.test(filedata)) {
|
|
pr = true;
|
|
break;
|
|
}
|
|
}
|
|
const mdir = yield getMDir(this.app, note, this.settings);
|
|
const obsmdir = yield getMDir(this.app, note, this.settings, true);
|
|
let embeds = metaCache === null || metaCache === void 0 ? void 0 : metaCache.embeds;
|
|
if (obsmdir != "" && !(yield this.app.vault.adapter.exists(obsmdir))) {
|
|
if (!this.settings.DoNotCreateObsFolder) {
|
|
this.ensureFolderExists(obsmdir);
|
|
showBalloon("You obsidian media folder set to '" + obsmdir + "', and has been created by the plugin. Please, try again. ", this.settings.showNotifications);
|
|
onRet();
|
|
}
|
|
return;
|
|
}
|
|
if (embeds || pr) {
|
|
yield this.ensureFolderExists(mdir);
|
|
for (let el of embeds) {
|
|
logError(el);
|
|
let oldpath = pathJoin([obsmdir, path__default["default"].basename(el.link)]);
|
|
let oldtag = el["original"];
|
|
logError(useMdLinks);
|
|
logError(this.newfCreated);
|
|
if ((this.newfCreated.indexOf(el.link) != -1 || (obsmdir != "" && (this.newfCreated.includes(oldpath) || this.newfCreated.includes(el.link)))) &&
|
|
!this.newfCreatedByDownloader.includes(oldtag)) {
|
|
if (!(yield this.app.vault.adapter.exists(oldpath))) {
|
|
logError("Cannot find " + el.link + " skipping...");
|
|
continue;
|
|
}
|
|
let newpath = pathJoin([mdir, cFileName(path__default["default"].basename(el.link))]);
|
|
let newlink = yield getRDir(note, this.settings, newpath);
|
|
logError(el.link);
|
|
//let newBinData: Buffer | null = null
|
|
let newBinData = null;
|
|
let newMD5 = null;
|
|
const oldBinData = yield readFromDiskB(pathJoin([this.app.vault.adapter.basePath, oldpath]), 5000);
|
|
const oldMD5 = md5Sig(oldBinData);
|
|
const fileExt = yield getFileExt(oldBinData, oldpath);
|
|
logError("oldbindata: " + oldBinData);
|
|
logError("oldext: " + fileExt);
|
|
if (this.settings.PngToJpegLocal && fileExt == "png") {
|
|
let compType = "image/jpg";
|
|
let compExt = ".jpg";
|
|
if (this.settings.ImgCompressionType == "image/webp") {
|
|
compType = "image/webp";
|
|
compExt = ".webp";
|
|
}
|
|
logError("Compressing image to ");
|
|
const blob = new Blob([new Uint8Array(yield this.app.vault.adapter.readBinary(oldpath))]);
|
|
newBinData = yield blobToJpegArrayBuffer(blob, this.settings.JpegQuality * 0.01, compType);
|
|
newMD5 = md5Sig(newBinData);
|
|
logError(newBinData);
|
|
if (newBinData != null) {
|
|
if (this.settings.useMD5ForNewAtt) {
|
|
newpath = pathJoin([mdir, newMD5 + compExt]);
|
|
}
|
|
else {
|
|
newpath = pathJoin([mdir, cFileName(((_f = path__default["default"].parse(el.link)) === null || _f === void 0 ? void 0 : _f.name) + compExt)]);
|
|
}
|
|
newlink = yield getRDir(note, this.settings, newpath);
|
|
}
|
|
}
|
|
else if (this.settings.useMD5ForNewAtt) {
|
|
newpath = pathJoin([mdir, oldMD5 + path__default["default"].extname(el.link)]);
|
|
newlink = yield getRDir(note, this.settings, newpath);
|
|
}
|
|
else if (!this.settings.useMD5ForNewAtt) {
|
|
newpath = pathJoin([mdir, cFileName(path__default["default"].basename(el.link))]);
|
|
newlink = yield getRDir(note, this.settings, newpath);
|
|
}
|
|
if (yield this.app.vault.adapter.exists(newpath)) {
|
|
let newFMD5;
|
|
if (newBinData != null) {
|
|
newFMD5 = md5Sig(yield this.app.vault.adapter.readBinary(newpath));
|
|
}
|
|
else {
|
|
newFMD5 = md5Sig(yield readFromDiskB(pathJoin([this.app.vault.adapter.basePath, newpath]), 5000));
|
|
}
|
|
if (newMD5 === newFMD5 || (oldMD5 === newFMD5 && oldpath != newpath)) {
|
|
logError(path__default["default"].dirname(oldpath));
|
|
logError("Deleting duplicate file: " + oldpath);
|
|
yield this.app.vault.adapter.remove(oldpath);
|
|
}
|
|
else if (oldpath != newpath) {
|
|
logError("Renaming existing: " + oldpath);
|
|
let inc = 1;
|
|
while (yield this.app.vault.adapter.exists(newpath)) {
|
|
newpath = pathJoin([mdir, `(${inc}) ` + cFileName(path__default["default"].basename(el.link))]);
|
|
inc++;
|
|
}
|
|
newlink = yield getRDir(note, this.settings, newpath);
|
|
yield this.app.vault.adapter.rename(oldpath, newpath);
|
|
}
|
|
}
|
|
else {
|
|
logError(`renaming ${oldpath} to ${newpath}`);
|
|
try {
|
|
if (newBinData != null) {
|
|
yield this.app.vault.adapter.writeBinary(newpath, newBinData).then();
|
|
{
|
|
yield this.app.vault.adapter.remove(oldpath);
|
|
}
|
|
}
|
|
else {
|
|
yield this.app.vault.adapter.rename(oldpath, newpath);
|
|
}
|
|
}
|
|
catch (error) {
|
|
logError(error);
|
|
}
|
|
}
|
|
let addName = "";
|
|
if (this.settings.addNameOfFile) {
|
|
if (useMdLinks) {
|
|
addName = `[Open: ${path__default["default"].basename(el.link)}](${newlink[1]})\r\n`;
|
|
}
|
|
else {
|
|
addName = `[[${newlink[0]}|Open: ${path__default["default"].basename(el.link)}]]\r\n`;
|
|
}
|
|
}
|
|
let newtag = addName + oldtag.replace(el.link, newlink[0]);
|
|
if (useMdLinks) {
|
|
newtag = addName + oldtag.replace(encObsURI(el.link), newlink[1]);
|
|
}
|
|
filedata = filedata.replaceAll(oldtag, newtag);
|
|
itemcount++;
|
|
}
|
|
}
|
|
}
|
|
if (itemcount > 0) {
|
|
yield this.app.vault.modify(note, filedata);
|
|
showBalloon(itemcount + " attachments for note " + note.path + " were processed.", this.settings.showNotifications);
|
|
itemcount = 0;
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
logError(e);
|
|
onRet();
|
|
}
|
|
onRet();
|
|
});
|
|
this.setTitleAsName = () => __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
const noteFile = this.getCurrentNote();
|
|
const fileData = yield this.app.vault.cachedRead(noteFile);
|
|
const title = fileData.match(/^#{1,6} .+?($|\n)/gm);
|
|
var ind = 0;
|
|
if (title !== null) {
|
|
const newName = cFileName(trimAny(title[0].toString(), ["#", " "])).slice(0, 200);
|
|
var fullPath = pathJoin([noteFile.parent.path, newName + ".md"]);
|
|
var fExist = yield this.app.vault.exists(fullPath);
|
|
if (trimAny(noteFile.path, ["\\", "/"]) != trimAny(fullPath, ["\\", "/"])) {
|
|
while (fExist) {
|
|
ind++;
|
|
var fullPath = pathJoin([noteFile.parent.path, newName + " (" + ind + ")" + ".md"]);
|
|
var fExist = yield this.app.vault.exists(fullPath);
|
|
}
|
|
yield this.app.vault.rename(noteFile, fullPath);
|
|
showBalloon(`The note was renamed to ` + fullPath, this.settings.showNotifications);
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
showBalloon(`Cannot rename.`, this.settings.showNotifications);
|
|
return;
|
|
}
|
|
});
|
|
this.convertSelToURI = () => __awaiter(this, void 0, void 0, function* () {
|
|
this.app.workspace.activeEditor.editor.replaceSelection(encObsURI(yield this.app.workspace.activeEditor.getSelection()));
|
|
});
|
|
this.convertSelToMD = () => __awaiter(this, void 0, void 0, function* () {
|
|
this.app.workspace.activeEditor.editor.replaceSelection(obsidian.htmlToMarkdown(yield this.app.workspace.activeEditor.getSelection()));
|
|
});
|
|
this.processModifiedQueue = () => __awaiter(this, void 0, void 0, function* () {
|
|
const iteration = this.modifiedQueue.iterationQueue();
|
|
for (const page of iteration) {
|
|
this.processPage(page, false);
|
|
}
|
|
});
|
|
}
|
|
onload() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
yield this.loadSettings();
|
|
this.addCommand({
|
|
id: "download-images",
|
|
name: "Localize attachments for the current note (plugin folder)",
|
|
callback: this.processActivePage(false),
|
|
});
|
|
this.addCommand({
|
|
id: "download-images-def",
|
|
name: "Localize attachments for the current note (Obsidian folder)",
|
|
callback: this.processActivePage(true),
|
|
});
|
|
if (!this.settings.disAddCom) {
|
|
this.addRibbonIcon("dice", APP_TITLE + "\r\nLocalize attachments (plugin folder)", () => {
|
|
this.processActivePage(false)();
|
|
});
|
|
this.addCommand({
|
|
id: "set-title-as-name",
|
|
name: "Set the first found # header as a note name.",
|
|
callback: this.setTitleAsName,
|
|
});
|
|
this.addCommand({
|
|
id: "download-images-all",
|
|
name: "Localize attachments for all your notes (plugin folder)",
|
|
callback: this.openProcessAllModal,
|
|
});
|
|
this.addCommand({
|
|
id: "convert-selection-to-URI",
|
|
name: "Convert selection to URI",
|
|
callback: this.convertSelToURI,
|
|
});
|
|
this.addCommand({
|
|
id: "convert-selection-to-md",
|
|
name: "Convert selection from html to markdown",
|
|
callback: this.convertSelToMD,
|
|
});
|
|
this.addCommand({
|
|
id: "remove-orphans-from-obsidian-folder",
|
|
name: "Remove all orphaned attachments (Obsidian folder)",
|
|
callback: () => { this.removeOrphans("obsidian")(); },
|
|
});
|
|
this.addCommand({
|
|
id: "remove-orphans-from-plugin-folder",
|
|
name: "Remove all orphaned attachments (Plugin folder)",
|
|
callback: () => { this.removeOrphans("plugin")(); },
|
|
});
|
|
}
|
|
// Some file has been created
|
|
this.app.vault.on('create', (file) => __awaiter(this, void 0, void 0, function* () {
|
|
var _a;
|
|
logError("New file created: " + file.path);
|
|
if (this.ExemplaryOfMD(file.path) && !this.ThePathExcluded(String((_a = file.parent) === null || _a === void 0 ? void 0 : _a.path))) {
|
|
this.onMdCreateFunc(file);
|
|
}
|
|
else {
|
|
this.onFCreateFunc(file);
|
|
}
|
|
}));
|
|
// Some file has been deleted
|
|
this.app.vault.on('delete', (file) => __awaiter(this, void 0, void 0, function* () {
|
|
if (!file ||
|
|
!(file instanceof obsidian.TFile) ||
|
|
!(this.ExemplaryOfMD(file.path)) ||
|
|
!this.settings.removeMediaFolder ||
|
|
this.settings.saveAttE != "nextToNoteS") {
|
|
return;
|
|
}
|
|
let rootdir = this.settings.mediaRootDir;
|
|
const useSysTrash = (this.app.vault.getConfig("trashOption") === "system");
|
|
if (this.settings.saveAttE !== "obsFolder" &&
|
|
path__default["default"].basename(rootdir).includes("${notename}") &&
|
|
!rootdir.includes("${date}")) {
|
|
rootdir = rootdir.replace("${notename}", file.basename);
|
|
if (this.settings.saveAttE == "nextToNoteS") {
|
|
rootdir = pathJoin([path__default["default"].dirname((file === null || file === void 0 ? void 0 : file.path) || ""), rootdir]);
|
|
}
|
|
try {
|
|
if (this.app.vault.getAbstractFileByPath(rootdir) instanceof obsidian.TFolder) {
|
|
this.app.vault.trash(app.vault.getAbstractFileByPath(rootdir), useSysTrash);
|
|
showBalloon("Attachment folder " + rootdir + " was moved to trash can.", this.settings.showNotifications);
|
|
}
|
|
}
|
|
catch (e) {
|
|
logError(e);
|
|
return;
|
|
}
|
|
}
|
|
}));
|
|
this.app.vault.on('rename', (file, oldPath) => __awaiter(this, void 0, void 0, function* () {
|
|
var _b, _c, _d, _e;
|
|
if (!file ||
|
|
!(file instanceof obsidian.TFile) ||
|
|
!this.ExemplaryOfMD(file.path) ||
|
|
this.ThePathExcluded(String((_b = file.parent) === null || _b === void 0 ? void 0 : _b.path)) ||
|
|
!this.settings.removeMediaFolder ||
|
|
this.settings.saveAttE != "nextToNoteS" ||
|
|
this.settings.pathInTags != "onlyRelative") {
|
|
return;
|
|
}
|
|
let oldRootdir = this.settings.mediaRootDir;
|
|
if (path__default["default"].basename(oldRootdir).includes("${notename}") &&
|
|
!oldRootdir.includes("${date}")) {
|
|
oldRootdir = oldRootdir.replace("${notename}", (_c = path__default["default"].parse(oldPath)) === null || _c === void 0 ? void 0 : _c.name);
|
|
let newRootDir = oldRootdir.replace((_d = path__default["default"].parse(oldPath)) === null || _d === void 0 ? void 0 : _d.name, (_e = path__default["default"].parse(file.path)) === null || _e === void 0 ? void 0 : _e.name);
|
|
let newRootDir_ = newRootDir;
|
|
let oldRootdir_ = oldRootdir;
|
|
oldRootdir_ = pathJoin([(path__default["default"].dirname(oldPath) || ""), oldRootdir]);
|
|
newRootDir_ = pathJoin([(path__default["default"].dirname(file.path) || ""), newRootDir]);
|
|
try {
|
|
if (this.app.vault.getAbstractFileByPath(oldRootdir_) instanceof obsidian.TFolder) {
|
|
yield this.ensureFolderExists(path__default["default"].dirname(newRootDir_));
|
|
//await this.app.fileManager.renameFile(app.vault.getAbstractFileByPath(oldRootdir),newRootDir)
|
|
yield this.app.vault.adapter.rename(oldRootdir_, newRootDir_);
|
|
showBalloon("Attachment folder was renamed to " + newRootDir_, this.settings.showNotifications);
|
|
}
|
|
}
|
|
catch (e) {
|
|
showBalloon("Cannot move attachment folder: \r\n" + e, this.settings.showNotifications);
|
|
logError(e);
|
|
return;
|
|
}
|
|
let content = yield this.app.vault.cachedRead(file);
|
|
content = content
|
|
.replaceAll("](" + encodeURI(oldRootdir), "](" + encodeURI(newRootDir))
|
|
.replaceAll("[" + oldRootdir, "[" + newRootDir);
|
|
this.app.vault.modify(file, content);
|
|
}
|
|
}));
|
|
// Some file has been modified
|
|
this.app.vault.on('modify', (file) => __awaiter(this, void 0, void 0, function* () {
|
|
var _f;
|
|
if (!this.newfMoveReq)
|
|
return;
|
|
logError("File modified: " + file.path, false);
|
|
if (!file ||
|
|
!(file instanceof obsidian.TFile) ||
|
|
this.ThePathExcluded(String((_f = file.parent) === null || _f === void 0 ? void 0 : _f.path)) ||
|
|
!this.ExemplaryOfMD(file.path)) {
|
|
return;
|
|
}
|
|
else {
|
|
if (this.settings.processAll) {
|
|
if (!this.noteModified.includes(file)) {
|
|
this.noteModified.push(file);
|
|
}
|
|
this.setupNewMdFilesProcInterval();
|
|
}
|
|
}
|
|
}));
|
|
this.app.workspace.on("editor-paste", (evt, editor, info) => {
|
|
this.onPasteFunc(evt, editor, info);
|
|
});
|
|
this.setupQueueInterval();
|
|
this.addSettingTab(new SettingTab(this.app, this));
|
|
});
|
|
}
|
|
setupQueueInterval() {
|
|
if (this.intervalId) {
|
|
const intervalId = this.intervalId;
|
|
this.intervalId = 0;
|
|
window.clearInterval(intervalId);
|
|
}
|
|
if (this.settings.realTimeUpdate &&
|
|
this.settings.realTimeUpdateInterval > 0) {
|
|
this.intervalId = window.setInterval(this.processModifiedQueue, this.settings.realTimeUpdateInterval * 1000);
|
|
this.registerInterval(this.intervalId);
|
|
}
|
|
}
|
|
getCurrentNote() {
|
|
try {
|
|
const noteFile = app.workspace.activeEditor.file;
|
|
return noteFile;
|
|
}
|
|
catch (e) {
|
|
showBalloon("Cannot get current note! ", this.settings.showNotifications);
|
|
}
|
|
return null;
|
|
}
|
|
processPage(file, defaultdir = false) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (file == null) {
|
|
return null;
|
|
}
|
|
const content = yield this.app.vault.cachedRead(file);
|
|
if (content.length == 0) {
|
|
return null;
|
|
}
|
|
const fixedContent = yield replaceAsync(content, MD_SEARCH_PATTERN, imageTagProcessor(this, file, this.settings, defaultdir));
|
|
if (content != fixedContent[0] && fixedContent[1] === false) {
|
|
this.modifiedQueue.remove(file);
|
|
yield this.app.vault.modify(file, fixedContent[0]);
|
|
fixedContent[2].forEach((element) => {
|
|
this.newfCreatedByDownloader.push(element);
|
|
});
|
|
showBalloon(`Attachments for "${file.path}" were processed.`, this.settings.showNotifications);
|
|
}
|
|
else if (content != fixedContent[0] && fixedContent[1] === true) {
|
|
this.modifiedQueue.remove(file);
|
|
yield this.app.vault.modify(file, fixedContent[0]);
|
|
fixedContent[2].forEach((element) => {
|
|
this.newfCreatedByDownloader.push(element);
|
|
});
|
|
showBalloon(`WARNING!\r\nAttachments for "${file.path}" were processed, but some attachments were not downloaded/replaced...`, this.settings.showNotifications);
|
|
}
|
|
else {
|
|
if (this.settings.showNotifications) {
|
|
showBalloon(`Page "${file.path}" has been processed, but nothing was changed.`, this.settings.showNotifications);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
onPasteFunc(evt = undefined, editor = undefined, info = undefined) {
|
|
var _a;
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (evt === undefined) {
|
|
return;
|
|
}
|
|
if (!this.settings.realTimeUpdate) {
|
|
return;
|
|
}
|
|
try {
|
|
const activeFile = this.getCurrentNote();
|
|
const fItems = evt.clipboardData.files;
|
|
const tItems = evt.clipboardData.items;
|
|
if (fItems.length != 0 || this.ThePathExcluded(String((_a = activeFile.parent) === null || _a === void 0 ? void 0 : _a.path))) {
|
|
return;
|
|
}
|
|
for (const key in tItems) {
|
|
// Check if it was a text/html
|
|
if (tItems[key].kind == "string") {
|
|
if (this.settings.realTimeUpdate) {
|
|
const cont = obsidian.htmlToMarkdown(evt.clipboardData.getData("text/html")) +
|
|
obsidian.htmlToMarkdown(evt.clipboardData.getData("text"));
|
|
for (const reg_p of MD_SEARCH_PATTERN) {
|
|
if (reg_p.test(cont)) {
|
|
logError("content: " + cont);
|
|
showBalloon("Media links were found, processing...", this.settings.showNotifications);
|
|
this.enqueueActivePage(activeFile);
|
|
this.setupQueueInterval();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
showBalloon(`Please select a note or click inside selected note in canvas.`, this.settings.showNotifications);
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
onMdCreateFunc(file) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!file ||
|
|
!(file instanceof obsidian.TFile) ||
|
|
!(this.settings.processCreated) ||
|
|
!this.ExemplaryOfMD(file.path))
|
|
return;
|
|
const timeGapMs = Math.abs(Date.now() - file.stat.ctime);
|
|
if (timeGapMs > 1000)
|
|
return;
|
|
logError("func onMdCreateFunc: " + file.path);
|
|
logError(file, true);
|
|
var cont = yield this.app.vault.cachedRead(file);
|
|
logError(cont);
|
|
this.enqueueActivePage(file);
|
|
this.setupQueueInterval();
|
|
this.setupNewMdFilesProcInterval();
|
|
});
|
|
}
|
|
onFCreateFunc(file) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!file ||
|
|
!(file instanceof obsidian.TFile) ||
|
|
this.ExemplaryOfMD(file.path) ||
|
|
this.ExemplaryOfCANVAS(file.path) ||
|
|
!(this.settings.processAll))
|
|
return;
|
|
if (!file.stat.ctime)
|
|
return;
|
|
const timeGapMs = Math.abs(Date.now() - file.stat.mtime);
|
|
if (timeGapMs > 1000)
|
|
return;
|
|
this.newfCreated.push(file.path);
|
|
this.newfMoveReq = true;
|
|
this.setupNewMdFilesProcInterval();
|
|
logError("file created ");
|
|
});
|
|
}
|
|
ExemplaryOfMD(pat) {
|
|
var _a, _b;
|
|
const includeRegex = new RegExp(this.settings.includepattern, "i");
|
|
return (((_b = (_a = pat.match(includeRegex)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.md) != undefined);
|
|
}
|
|
ExemplaryOfCANVAS(pat) {
|
|
var _a, _b;
|
|
const includeRegex = new RegExp(this.settings.includepattern, "i");
|
|
return (((_b = (_a = pat.match(includeRegex)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b.canvas) != undefined);
|
|
}
|
|
ThePathExcluded(pat) {
|
|
const includeRegex = new RegExp(this.settings.ExcludedFoldersListRegexp, "i");
|
|
logError(pat.match(includeRegex));
|
|
// if (pat.match(includeRegex) != null && trimAny(this.settings.ExcludedFoldersList, [" "]).length != 0){
|
|
// showBalloon("The path " + pat + " is excluded in your settings. ", true)}
|
|
return (pat.match(includeRegex) != null && trimAny(this.settings.ExcludedFoldersList, [" "]).length != 0);
|
|
}
|
|
setupNewMdFilesProcInterval() {
|
|
logError("func setupNewFilesProcInterval: \r\n");
|
|
window.clearInterval(this.newfProcInt);
|
|
this.newfProcInt = 0;
|
|
this.newfProcInt = window.setInterval(this.processMdFilesOnTimer, this.settings.realTimeUpdateInterval * 1000);
|
|
this.registerInterval(this.newfProcInt);
|
|
}
|
|
enqueueActivePage(activeFile) {
|
|
this.modifiedQueue.push(activeFile, 1 //this.settings.realTim3AttemptsToProcess
|
|
);
|
|
}
|
|
// ------------ Load / Save settings -----------------
|
|
onunload() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this.app.workspace.off("editor-drop", null);
|
|
this.app.workspace.off("editor-paste", null);
|
|
this.app.workspace.off('file-menu', null);
|
|
//this.app.vault.off("create", null)
|
|
logError(" unloaded.");
|
|
});
|
|
}
|
|
loadSettings() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
|
|
this.setupQueueInterval();
|
|
});
|
|
}
|
|
saveSettings() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
yield this.saveData(this.settings);
|
|
}
|
|
catch (error) {
|
|
displayError(error);
|
|
}
|
|
});
|
|
}
|
|
ensureFolderExists(folderPath) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
try {
|
|
yield this.app.vault.createFolder(folderPath);
|
|
return;
|
|
}
|
|
catch (e) {
|
|
logError(e);
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = LocalImagesPlugin;
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["../node_modules/tslib/tslib.es6.js","../node_modules/strtok3/lib/FsPromise.js","../node_modules/peek-readable/lib/EndOfFileStream.js","../node_modules/peek-readable/lib/Deferred.js","../node_modules/peek-readable/lib/StreamReader.js","../node_modules/peek-readable/lib/index.js","../node_modules/strtok3/lib/AbstractTokenizer.js","../node_modules/strtok3/lib/ReadStreamTokenizer.js","../node_modules/strtok3/lib/BufferTokenizer.js","../node_modules/strtok3/lib/core.js","../node_modules/strtok3/lib/FileTokenizer.js","../node_modules/strtok3/lib/index.js","../node_modules/ieee754/index.js","../node_modules/token-types/lib/index.js","../node_modules/file-type/util.js","../node_modules/file-type/supported.js","../node_modules/file-type/core.js","../node_modules/file-type/index.js","../node_modules/fast-xml-parser/src/util.js","../node_modules/fast-xml-parser/src/validator.js","../node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js","../node_modules/fast-xml-parser/src/xmlparser/xmlNode.js","../node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js","../node_modules/strnum/strnum.js","../node_modules/fast-xml-parser/src/ignoreAttributes.js","../node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js","../node_modules/fast-xml-parser/src/xmlparser/node2json.js","../node_modules/fast-xml-parser/src/xmlparser/XMLParser.js","../node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js","../node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js","../node_modules/fast-xml-parser/src/fxp.js","../node_modules/is-svg/index.js","../node_modules/escape-string-regexp/index.js","../node_modules/trim-repeated/index.js","../node_modules/filename-reserved-regex/index.js","../node_modules/strip-outer/index.js","../node_modules/filenamify/filenamify.js","../node_modules/crypto-js/core.js","../node_modules/crypto-js/md5.js","../src/config.ts","../src/utils.ts","../node_modules/safe-regex/lib/analyzer.js","../node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-dotall-s-transform.js","../node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-named-capturing-groups-transform.js","../node_modules/regexp-tree/dist/compat-transpiler/transforms/compat-x-flag-transform.js","../node_modules/regexp-tree/dist/compat-transpiler/transforms/index.js","../node_modules/regexp-tree/dist/generator/index.js","../node_modules/regexp-tree/dist/parser/unicode/parser-unicode-properties.js","../node_modules/regexp-tree/dist/parser/generated/regexp-tree.js","../node_modules/regexp-tree/dist/parser/index.js","../node_modules/regexp-tree/dist/traverse/node-path.js","../node_modules/regexp-tree/dist/traverse/index.js","../node_modules/regexp-tree/dist/transform/index.js","../node_modules/regexp-tree/dist/compat-transpiler/index.js","../node_modules/regexp-tree/dist/utils/clone.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-surrogate-pair-to-single-unicode-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-code-to-simple-char-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-case-insensitive-lowercase-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-class-remove-duplicates-transform.js","../node_modules/regexp-tree/dist/transform/utils.js","../node_modules/regexp-tree/dist/optimizer/transforms/quantifiers-merge-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/quantifier-range-to-symbol-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-class-classranges-to-chars-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-class-to-meta-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-class-to-single-char-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-escape-unescape-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/char-class-classranges-merge-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/disjunction-remove-duplicates-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/group-single-chars-to-char-class.js","../node_modules/regexp-tree/dist/optimizer/transforms/remove-empty-group-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/ungroup-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/combine-repeating-patterns-transform.js","../node_modules/regexp-tree/dist/optimizer/transforms/index.js","../node_modules/regexp-tree/dist/optimizer/index.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/special-symbols.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa-minimizer.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/dfa/dfa.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/state.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa-state.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/builders.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/nfa/nfa-from-regexp.js","../node_modules/regexp-tree/dist/interpreter/finite-automaton/index.js","../node_modules/regexp-tree/dist/compat-transpiler/runtime/index.js","../node_modules/regexp-tree/dist/regexp-tree.js","../node_modules/regexp-tree/index.js","../node_modules/safe-regex/lib/heuristic-analyzer.js","../node_modules/safe-regex/lib/analyzer-family.js","../node_modules/safe-regex/index.js","../src/settingstab.ts","../node_modules/async-lock/lib/index.js","../node_modules/async-lock/index.js","../node_modules/moment/moment.js","../src/contentProcessor.ts","../src/uniqueQueue.ts","../src/modal.ts","../src/main.ts"],"sourcesContent":null,"names":["fs","require$$0","Deferred_1","require$$1","AbstractTokenizer_1","peek_readable_1","ReadStreamTokenizer_1","BufferTokenizer_1","require$$2","FileTokenizer_1","fromFile","ieee754","util","supported","strtok3","require$$3","fileType","core","defaultOptions","validator","buildOptions","xmlNode","readDocType","toNumber","getIgnoreAttributesFn","require$$4","OrderedObjParser","replaceEntitiesValue","prettify","propName","XMLParser","isSvgModule","escapeStringRegexp","filenameReservedRegexModule","trimRepeated","stripOuter","this","undefined","global","require","Notice","requestUrl","path","fromBuffer","isSvg","analyzer","transforms","gen","generator","_slicedToArray","_toConsumableArray","regexpTree","parser","_createClass","_classCallCheck","NodePath","traverse","transform","_transform","compatTranspiler","clone","UPPER_A_CP","UPPER_Z_CP","disjunctionToList","listToDisjunction","increaseQuantifierByOne","_require","hasAppropriateSiblings","isMeta","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","optimizer","EPSILON","EPSILON_CLOSURE","NFA","DFA","State","NFAState","char","alt","or","rep","plusRep","questionRep","builders","RegExpTree","heuristicAnalyzer","analyzerFamily","PluginSettingTab","Setting","safeRegex","AsyncLock","URL","Modal","Plugin","htmlToMarkdown","TFile","TFolder"],"mappings":"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AAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAC1C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAC1C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAC1C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAC1C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxD;cACa,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxD;cACa,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxD;cACa,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;cAC3C,CAAC,GAAG,EAAE,CAAC,CAAC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EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;AAC5uxB;AACA;AACA;AACA;AACA,IAAI,KAAK,GAAG,EAAE,CAAC;AACf;AACA;AACA;AACA;AACA,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,QAAQ,GAAG,CAAC,CAAC,UAAU,EAAE,YAAY,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,uBAAuB,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY;AACnI,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY;AACvB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,UAAU,EAAE,YAAY;AAC7B,EAAE,OAAO,aAAa,CAAC;AACvB,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,YAAY;AAC9B,EAAE,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC,EAAE,CAAC,cAAc,EAAE,YAAY;AACjC,EAAE,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC,EAAE,CAAC,oglBAAoglB,EAAE,YAAY;AACvhlB,EAAE,IAAI,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACtC,EAAE,wBAAwB,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;AAC9D,EAAE,OAAO,iBAAiB,CAAC;AAC3B,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY;AACzB,EAAE,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY;AACzB,EAAE,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC,EAAE,CAAC,cAAc,EAAE,YAAY;AACjC,EAAE,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC,EAAE,CAAC,aAAa,EAAE,YAAY;AAChC,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY;AACzB,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY;AAC/B,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,6DAA6D,EAAE,YAAY;AAChF,EAAE,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC,EAAE,CAAC,yBAAyB,EAAE,YAAY;AAC5C,EAAE,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,EAAE,CAAC,oBAAoB,EAAE,YAAY;AACvC,EAAE,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,EAAE,CAAC,yBAAyB,EAAE,YAAY;AAC5C,EAAE,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC,EAAE,CAAC,oBAAoB,EAAE,YAAY;AACvC,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,kBAAkB,EAAE,YAAY;AACrC,EAAE,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY;AAC1B,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY;AAC5B,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,qCAAqC,EAAE,YAAY;AACxD,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,kBAAkB,EAAE,YAAY;AACrC,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;AACjC,EAAE,IAAI,CAAC,KAAK,SAAS,IAAI,MAAM,KAAK,KAAK,EAAE;AAC3C,IAAI,OAAO,UAAU,CAAC;AACtB,GAAG,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE;AACzD,IAAI,MAAM,IAAI,WAAW,CAAC,yBAAyB,GAAG,MAAM,CAAC,CAAC;AAC9D,GAAG;AACH,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY;AAC3B,EAAE,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY;AAC3B,EAAE,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY;AAC5B,EAAE,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC,EAAE,CAAC,SAAS,EAAE,YAAY;AAC5B,EAAE,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY;AAC3B,EAAE,OAAO,mBAAmB,CAAC;AAC7B,CAAC,CAAC,EAAE,CAAC,qglBAAqglB,EAAE,YAAY;AACxhlB,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC/B,EAAE,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;AAC3D,EAAE,OAAO,qBAAqB,CAAC;AAC/B,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,YAAY;AAC9B,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY;AAC1B,EAAE,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,WAAW,CAAC;AACrC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC,EAAE,CAAC,gBAAgB,EAAE,YAAY;AACnC,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY;AAC1B,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,OAAO,WAAW,CAAC;AAClH,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY;AACxB,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,OAAO,WAAW,CAAC;AAClH,CAAC,CAAC,CAAC,CAAC;AACJ,IAAI,oBAAoB,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,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"}
|