466 lines
12 KiB
TypeScript
466 lines
12 KiB
TypeScript
// Module ID: 11602
|
|
// Function ID: 11603
|
|
// Name: getMatch
|
|
// Dependencies: [2]
|
|
|
|
// Module 11602 (getMatch)
|
|
function getMatch(str, arg1, index) {
|
|
let tmp3;
|
|
if (null == arg1) {
|
|
return null;
|
|
} else {
|
|
let num10 = 0;
|
|
if (0 < arg1.length) {
|
|
while (true) {
|
|
let obj = arg1[num10];
|
|
let match = str.match(obj.regex);
|
|
let tmp2 = num10;
|
|
tmp3 = null;
|
|
if (null != match) {
|
|
let items = [];
|
|
let tmp4 = items;
|
|
let tmp5 = match;
|
|
let num = 0;
|
|
let arraySpreadResult = HermesBuiltin.arraySpread(match, 0);
|
|
items.index = index;
|
|
tmp3 = items;
|
|
}
|
|
if (null != tmp3) {
|
|
let cache = obj.cache;
|
|
let tmp8 = null != cache;
|
|
index = undefined;
|
|
if (tmp8) {
|
|
let value = cache.get(tmp3[0]);
|
|
tmp8 = null != value;
|
|
index = value;
|
|
}
|
|
let tmp10 = index;
|
|
if (tmp8) {
|
|
break;
|
|
} else {
|
|
if (null == tmp10) {
|
|
let type = obj.type;
|
|
let tmp33 = new.target;
|
|
let tmp32 = Token;
|
|
if (typeof Token !== "function") {
|
|
let str2 = "Trying to call a non-function";
|
|
let throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
}
|
|
obj = Object.create(tmp32.prototype);
|
|
let tmp22 = Token;
|
|
if (tmp3 instanceof Token) {
|
|
let items1 = [];
|
|
let tmp26 = items1;
|
|
let num9 = 0;
|
|
arraySpreadResult = HermesBuiltin.arraySpread(tmp3.match, 0);
|
|
obj.match = items1;
|
|
({ start: tmp21.start, type: tmp21.type } = tmp3);
|
|
if (null != tmp3._data) {
|
|
obj._data = tmp3._data;
|
|
}
|
|
} else if (null != tmp3) {
|
|
let items2 = [];
|
|
let tmp23 = items2;
|
|
let tmp24 = tmp3;
|
|
let num6 = 0;
|
|
let arraySpreadResult1 = HermesBuiltin.arraySpread(tmp3, 0);
|
|
obj.match = items2;
|
|
let num7 = 0;
|
|
if (typeof tmp3 !== "string") {
|
|
let num8 = tmp3.index;
|
|
if (num8 == null) {
|
|
num8 = 0;
|
|
}
|
|
num7 = num8;
|
|
}
|
|
obj.start = num7;
|
|
obj.type = type;
|
|
} else {
|
|
obj.match = [];
|
|
obj.start = 0;
|
|
obj.type = type;
|
|
}
|
|
let tmp28 = null == cache;
|
|
if (!tmp28) {
|
|
let hasItem;
|
|
if (cache != null) {
|
|
hasItem = cache.has(tmp3[0]);
|
|
}
|
|
tmp28 = hasItem;
|
|
}
|
|
tmp10 = obj;
|
|
if (!tmp28) {
|
|
let result = cache.set(tmp3[0], obj);
|
|
tmp10 = obj;
|
|
}
|
|
}
|
|
return tmp10;
|
|
}
|
|
}
|
|
num10 = num10 + 1;
|
|
}
|
|
if (typeof Token !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
obj = Object.create(Token.prototype);
|
|
if (index instanceof Token) {
|
|
const items3 = [];
|
|
HermesBuiltin.arraySpread(index.match, 0);
|
|
obj.match = items3;
|
|
({ start: tmp13.start, type: tmp13.type } = index);
|
|
if (null != index._data) {
|
|
obj._data = index._data;
|
|
}
|
|
index = tmp3.index;
|
|
obj.start = index;
|
|
} else if (null == index) {
|
|
obj.match = [];
|
|
obj.start = 0;
|
|
obj.type = undefined;
|
|
}
|
|
const items4 = [];
|
|
HermesBuiltin.arraySpread(index, 0);
|
|
obj.match = items4;
|
|
let num3 = 0;
|
|
if (typeof index !== "string") {
|
|
let num4 = index.index;
|
|
if (num4 == null) {
|
|
num4 = 0;
|
|
}
|
|
num3 = num4;
|
|
}
|
|
obj.start = num3;
|
|
obj.type = undefined;
|
|
const tmp11 = Token;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
const re0 = /.+/g;
|
|
const NON_TOKEN = "NON_TOKEN";
|
|
class QueryTokenizer {
|
|
constructor() {
|
|
items = global;
|
|
if (global === undefined) {
|
|
items = [];
|
|
}
|
|
obj = Object.create(new.target.prototype);
|
|
closure_0 = obj;
|
|
obj._rules = [];
|
|
obj._followers = {};
|
|
obj._nonTokenType = NON_TOKEN;
|
|
resetResult = obj.reset();
|
|
item = items.forEach((arg0) => obj.addRule(arg0));
|
|
return obj;
|
|
}
|
|
}
|
|
const prototype = QueryTokenizer.prototype;
|
|
prototype["reset"] = function reset() {
|
|
this._rules = [];
|
|
this._followers = {};
|
|
this._nonTokenType = NON_TOKEN;
|
|
};
|
|
prototype["addRule"] = function addRule(type) {
|
|
let follows;
|
|
let validator;
|
|
const self = this;
|
|
type = type.type;
|
|
({ follows, validator } = type);
|
|
const regex = type.regex;
|
|
let regExp = regex;
|
|
let tmp = regex;
|
|
if ("^" !== str.charAt(0)) {
|
|
const _RegExp = RegExp;
|
|
const _HermesInternal = HermesInternal;
|
|
regExp = new RegExp("^" + regex.source, regex.flags);
|
|
tmp = regExp;
|
|
}
|
|
if (null != validator) {
|
|
const _Map = Map;
|
|
const map = new Map();
|
|
const tmp7 = map;
|
|
}
|
|
if (null != follows) {
|
|
const item = follows.forEach((arg0) => {
|
|
if (null == self._followers[arg0]) {
|
|
tmp._followers[arg0] = [];
|
|
}
|
|
let arr = tmp._followers[arg0];
|
|
arr = arr.push({ regex: regExp, type, validator, cache: map });
|
|
});
|
|
} else {
|
|
const _rules = this._rules;
|
|
const obj = { regex: null, type: null, validator: null, cache: null };
|
|
obj[0] = tmp;
|
|
obj[1] = type;
|
|
obj[2] = validator;
|
|
obj[3] = tmp7;
|
|
_rules.push(obj);
|
|
}
|
|
};
|
|
prototype["tokenize"] = function tokenize(errorcode) {
|
|
let _data;
|
|
let _data2;
|
|
const self = this;
|
|
let str = errorcode;
|
|
const items = [];
|
|
let num = 0;
|
|
let str2 = "";
|
|
let num2 = 0;
|
|
let str3 = "";
|
|
if (errorcode.length > 0) {
|
|
while (true) {
|
|
let _getMatchResult = self._getMatch(str, tmp, num + ``.length);
|
|
let tmp2 = num;
|
|
let tmp3 = str2;
|
|
let tmp4 = str;
|
|
let tmp5 = tmp;
|
|
if (null != _getMatchResult) {
|
|
if ("" !== ``) {
|
|
break;
|
|
} else {
|
|
let arr = items.push(_getMatchResult);
|
|
let sum = num + (_getMatchResult.length + ``.length);
|
|
let substr = str.substring(_getMatchResult.length);
|
|
let str4 = "";
|
|
tmp5 = _getMatchResult;
|
|
}
|
|
} else {
|
|
str4 = str2 + str[0];
|
|
substr = str.substring(1);
|
|
sum = num;
|
|
}
|
|
num = sum;
|
|
str2 = str4;
|
|
str = substr;
|
|
tmp = tmp5;
|
|
num2 = sum;
|
|
str3 = str4;
|
|
}
|
|
const match = str2.match(closure_0);
|
|
_data = null;
|
|
if (null != match) {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(match, 0);
|
|
items1.index = num;
|
|
_data = items1;
|
|
}
|
|
_data = self._nonTokenType;
|
|
if (typeof Token !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
arr = Object.create(tmp32.prototype);
|
|
if (_data instanceof Token) {
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(_data.match, 0);
|
|
arr.match = items2;
|
|
({ start: tmp12.start, type: tmp12.type, _data } = _data);
|
|
if (null != _data) {
|
|
_data = _data._data;
|
|
arr._data = _data;
|
|
}
|
|
arr = items.push(arr);
|
|
} else if (null == _data) {
|
|
arr.match = [];
|
|
arr.start = 0;
|
|
arr.type = _data;
|
|
}
|
|
const items3 = [];
|
|
HermesBuiltin.arraySpread(_data, 0);
|
|
arr.match = items3;
|
|
let num5 = 0;
|
|
if (typeof _data !== "string") {
|
|
let num6 = _data.index;
|
|
if (num6 == null) {
|
|
num6 = 0;
|
|
}
|
|
num5 = num6;
|
|
}
|
|
arr.start = num5;
|
|
arr.type = _data;
|
|
}
|
|
if ("" === str3) {
|
|
return items;
|
|
} else {
|
|
const match1 = str3.match(closure_0);
|
|
let _data1 = null;
|
|
if (null != match1) {
|
|
const items4 = [];
|
|
HermesBuiltin.arraySpread(match1, 0);
|
|
items4.index = num2;
|
|
_data1 = items4;
|
|
}
|
|
_data2 = self._nonTokenType;
|
|
if (typeof Token !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
let obj = Object.create(tmp36.prototype);
|
|
if (_data1 instanceof Token) {
|
|
const items5 = [];
|
|
HermesBuiltin.arraySpread(_data1.match, 0);
|
|
obj.match = items5;
|
|
({ start: tmp25.start, type: tmp25.type, _data: _data2 } = _data1);
|
|
if (null != _data2) {
|
|
_data1 = _data1._data;
|
|
obj._data = _data1;
|
|
}
|
|
obj = items.push(obj);
|
|
} else if (null == _data1) {
|
|
obj.match = [];
|
|
obj.start = 0;
|
|
obj.type = _data2;
|
|
}
|
|
const items6 = [];
|
|
HermesBuiltin.arraySpread(_data1, 0);
|
|
obj.match = items6;
|
|
let num10 = 0;
|
|
if (typeof _data1 !== "string") {
|
|
let num11 = _data1.index;
|
|
if (num11 == null) {
|
|
num11 = 0;
|
|
}
|
|
num10 = num11;
|
|
}
|
|
obj.start = num10;
|
|
obj.type = _data2;
|
|
}
|
|
};
|
|
prototype["clearCache"] = function clearCache() {
|
|
const _rules = this._rules;
|
|
const item = _rules.forEach((cache) => {
|
|
cache = cache.cache;
|
|
let clearResult;
|
|
if (cache != null) {
|
|
clearResult = cache.clear();
|
|
}
|
|
return clearResult;
|
|
});
|
|
for (const key10008 in this._followers) {
|
|
let tmp2 = key10008;
|
|
let arr2 = this._followers[key10008];
|
|
let item1 = arr2.forEach((cache) => {
|
|
cache = cache.cache;
|
|
let clearResult;
|
|
if (cache != null) {
|
|
clearResult = cache.clear();
|
|
}
|
|
return clearResult;
|
|
});
|
|
continue;
|
|
}
|
|
};
|
|
prototype["_getMatch"] = function _getMatch(errorcode, type, arg2) {
|
|
type = null;
|
|
if (null != type) {
|
|
type = type.type;
|
|
}
|
|
let end;
|
|
if (type != null) {
|
|
end = type.end;
|
|
}
|
|
const self = this;
|
|
let tmp3;
|
|
if (end === arg2) {
|
|
const _String = String;
|
|
tmp3 = getMatch(errorcode, self._followers[String(undefined, type)], arg2);
|
|
}
|
|
if (null == tmp3) {
|
|
tmp3 = getMatch(errorcode, self._rules, arg2);
|
|
}
|
|
return tmp3;
|
|
};
|
|
let Token;
|
|
class Token {
|
|
constructor(arg0, arg1) {
|
|
obj = Object.create(new.target.prototype);
|
|
if (global instanceof Token) {
|
|
items = [];
|
|
num5 = 0;
|
|
tmp7 = items;
|
|
arraySpreadResult = HermesBuiltin.arraySpread(global.match, 0);
|
|
obj.match = items;
|
|
({ start: tmp.start, type: tmp.type } = global);
|
|
tmp9 = null;
|
|
if (null != global._data) {
|
|
obj._data = global._data;
|
|
}
|
|
} else {
|
|
tmp2 = require;
|
|
tmp3 = null;
|
|
if (null != global) {
|
|
items1 = [];
|
|
tmp4 = items1;
|
|
tmp5 = global;
|
|
num2 = 0;
|
|
arraySpreadResult1 = HermesBuiltin.arraySpread(global, 0);
|
|
obj.match = items1;
|
|
num3 = 0;
|
|
if (typeof global !== "string") {
|
|
num4 = global.index;
|
|
if (num4 == null) {
|
|
num4 = 0;
|
|
}
|
|
num3 = num4;
|
|
}
|
|
obj.start = num3;
|
|
obj.type = require;
|
|
} else {
|
|
obj.match = [];
|
|
num = 0;
|
|
obj.start = 0;
|
|
obj.type = require;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
const prototype2 = Token.prototype;
|
|
Object.defineProperty(prototype2, "end", {
|
|
get: function end() {
|
|
return this.start + this.length;
|
|
},
|
|
set: undefined
|
|
});
|
|
Object.defineProperty(prototype2, "length", {
|
|
get: function length() {
|
|
return this.match[0].length;
|
|
},
|
|
set: undefined
|
|
});
|
|
prototype2["valueOf"] = function valueOf() {
|
|
return this.match[0];
|
|
};
|
|
prototype2["getFullMatch"] = function getFullMatch() {
|
|
return this.match[0];
|
|
};
|
|
prototype2["getMatch"] = function getMatch() {
|
|
let num = arg0;
|
|
if (arg0 === undefined) {
|
|
num = 0;
|
|
}
|
|
return this.match[num];
|
|
};
|
|
prototype2["setData"] = function setData(arg0, arg1) {
|
|
const self = this;
|
|
if (null == this._data) {
|
|
const _Map = Map;
|
|
const map = new Map();
|
|
self._data = map;
|
|
}
|
|
const _data = self._data;
|
|
const result = _data.set(arg0, arg1);
|
|
};
|
|
prototype2["getData"] = function getData(arg0) {
|
|
if (null != this._data) {
|
|
const _data = tmp._data;
|
|
return _data.get(arg0);
|
|
}
|
|
};
|
|
QueryTokenizer.NON_TOKEN_TYPE = "NON_TOKEN";
|
|
QueryTokenizer.Token = Token;
|
|
let result = require("set").fileFinishedImporting("lib/QueryTokenizer.tsx");
|
|
|
|
export default QueryTokenizer;
|
|
export const NON_TOKEN_TYPE = "NON_TOKEN";
|
|
export { QueryTokenizer };
|
|
export { Token };
|