da5b5e5efe
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4821.js (118.4 MB)
766 lines
25 KiB
JavaScript
766 lines
25 KiB
JavaScript
// Module ID: 5329
|
|
// Function ID: 5330
|
|
// Dependencies: [32, 42, 41, 93, 95, 98, 158, 5294, 5330, 5331, 5332]
|
|
|
|
// Module 5329
|
|
import _wrapNativeSuperDefault from "_wrapNativeSuper" /* 158 */;
|
|
import _modDef5330 from "module_5330" /* 5330 */;
|
|
import calculateGPSValueDefault from "calculateGPSValue" /* 5332 */;
|
|
import _slicedToArray from "module_32" /* 32 */;
|
|
import _createClass from "_createClass" /* 42 */;
|
|
import _classCallCheck from "_classCallCheck" /* 41 */;
|
|
import hasOwnProperty from "_possibleConstructorReturn" /* 93 */;
|
|
import _getPrototypeOf from "_getPrototypeOf" /* 95 */;
|
|
import _inherits from "_inherits" /* 98 */;
|
|
|
|
const ParseError = arg1;
|
|
function _isNativeReflectConstruct() {
|
|
try {
|
|
const _Boolean = Boolean;
|
|
const call = valueOf.call;
|
|
const _Reflect = Reflect;
|
|
const _Boolean2 = Boolean;
|
|
if (typeof call === "unknown") {
|
|
let callResult = valueOf();
|
|
} else {
|
|
callResult = call(constructResult);
|
|
}
|
|
closure_0 = !callResult;
|
|
_isNativeReflectConstruct = function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
};
|
|
return _isNativeReflectConstruct();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
function readTags(_raw, buffer, arg2) {
|
|
try {
|
|
let str = _raw._raw;
|
|
({ doc, raw } = (function getDocument(byteLength, arg1) {
|
|
value = _modDef5330.get(arg1);
|
|
if (value) {
|
|
let str2 = byteLength;
|
|
if (typeof byteLength !== "string") {
|
|
str2 = ParseError(tmp[7]).getStringFromDataView(byteLength, 0, byteLength.byteLength);
|
|
const obj3 = ParseError(tmp[7]);
|
|
}
|
|
const obj2 = { doc: parseFromString(value, str2.replace(/^.+(<\?xpacket begin)/, "$1").replace(/(<\?xpacket end=".*"\?>).+$/, "$1")), raw: str2 };
|
|
return obj2;
|
|
} else {
|
|
const _console = console;
|
|
console.warn("Warning: DOMParser is not available. It is needed to be able to parse XMP tags.");
|
|
const _Error = Error;
|
|
const error = new Error();
|
|
throw error;
|
|
}
|
|
tmp = dependencyMap;
|
|
})(buffer, arg2));
|
|
if (!str) {
|
|
str = "";
|
|
}
|
|
_raw._raw = str + raw;
|
|
const tmp4 = (function getDocument(byteLength, arg1) {
|
|
value = _modDef5330.get(arg1);
|
|
if (value) {
|
|
let str2 = byteLength;
|
|
if (typeof byteLength !== "string") {
|
|
str2 = ParseError(tmp[7]).getStringFromDataView(byteLength, 0, byteLength.byteLength);
|
|
const obj3 = ParseError(tmp[7]);
|
|
}
|
|
const obj2 = { doc: parseFromString(value, str2.replace(/^.+(<\?xpacket begin)/, "$1").replace(/(<\?xpacket end=".*"\?>).+$/, "$1")), raw: str2 };
|
|
return obj2;
|
|
} else {
|
|
const _console = console;
|
|
console.warn("Warning: DOMParser is not available. It is needed to be able to parse XMP tags.");
|
|
const _Error = Error;
|
|
const error = new Error();
|
|
throw error;
|
|
}
|
|
tmp = dependencyMap;
|
|
})(buffer, arg2);
|
|
const tmp6 = getRDF(doc);
|
|
ParseError(5294).objectAssign(_raw, parseXMPObject(convertToObject(tmp6, true)));
|
|
return true;
|
|
} catch (err) {
|
|
return false;
|
|
}
|
|
}
|
|
function parseFromString(parseFromString, tmp13Result) {
|
|
try {
|
|
const parseFromStringResult = parseFromString.parseFromString(tmp13Result, "application/xml");
|
|
const elements = parseFromStringResult.getElementsByTagName("parsererror");
|
|
if (elements.length > 0) {
|
|
const tmp10 = new closure_8(elements[0].textContent);
|
|
throw tmp10;
|
|
} else {
|
|
return parseFromStringResult;
|
|
}
|
|
} catch (tmp12) {
|
|
if ("ParseError" === tmp12.name) {
|
|
if (obj2.isMissingNamespaceError(tmp12)) {
|
|
if (!tmp4) {
|
|
return parseFromString(tmp2, tmp13(5331).addMissingNamespaces(tmp), true);
|
|
}
|
|
}
|
|
obj2 = ParseError(5331);
|
|
tmp13 = ParseError;
|
|
}
|
|
throw tmp12;
|
|
}
|
|
}
|
|
function getRDF(doc) {
|
|
let num = 0;
|
|
if (0 < doc.childNodes.length) {
|
|
while ("x:xmpmeta" !== doc.childNodes[num].tagName) {
|
|
if ("rdf:RDF" === doc.childNodes[num].tagName) {
|
|
return doc.childNodes[num];
|
|
} else {
|
|
num = num + 1;
|
|
}
|
|
}
|
|
return getRDF(doc.childNodes[num]);
|
|
}
|
|
const error = new Error();
|
|
throw error;
|
|
}
|
|
function convertToObject(childNodes, arg1) {
|
|
let length;
|
|
let flag = arg1;
|
|
if (arg1 === undefined) {
|
|
flag = false;
|
|
}
|
|
let items = [];
|
|
let num = 0;
|
|
if (0 < childNodes.childNodes.length) {
|
|
do {
|
|
let arr = items.push(childNodes.childNodes[num]);
|
|
num = num + 1;
|
|
length = childNodes.childNodes.length;
|
|
} while (num < length);
|
|
}
|
|
let tmp2 = 1 === items.length;
|
|
if (tmp2) {
|
|
tmp2 = "#text" === items[0].nodeName;
|
|
}
|
|
if (tmp2) {
|
|
if (flag) {
|
|
let obj2 = {};
|
|
}
|
|
} else {
|
|
let attributes = {};
|
|
const item = items.forEach((nodeName) => {
|
|
let length;
|
|
nodeName = nodeName.nodeName;
|
|
if (nodeName) {
|
|
nodeName = "#text" !== nodeName.nodeName;
|
|
}
|
|
if (nodeName) {
|
|
attributes = {};
|
|
let num3 = 0;
|
|
if (0 < nodeName.attributes.length) {
|
|
do {
|
|
let _decodeURIComponent = decodeURIComponent;
|
|
let _escape = escape;
|
|
attributes[nodeName.attributes[num3].nodeName] = decodeURIComponent(escape(nodeName.attributes[num3].value));
|
|
num3 = num3 + 1;
|
|
length = nodeName.attributes.length;
|
|
} while (num3 < length);
|
|
}
|
|
const obj2 = { attributes, value: convertToObject(nodeName) };
|
|
if (undefined !== attributes[nodeName.nodeName]) {
|
|
const _Array = Array;
|
|
if (!Array.isArray(tmp3[nodeName.nodeName])) {
|
|
const items = [tmp3[nodeName.nodeName]];
|
|
tmp3[nodeName.nodeName] = items;
|
|
}
|
|
tmp3[nodeName.nodeName].push(obj2);
|
|
} else {
|
|
tmp3[nodeName.nodeName] = obj2;
|
|
}
|
|
}
|
|
});
|
|
return attributes;
|
|
}
|
|
}
|
|
function parseXMPObject(str) {
|
|
const obj = {};
|
|
if (typeof str === "string") {
|
|
return str;
|
|
} else {
|
|
for (const key10002 in arg0) {
|
|
let tmp5 = arg0[key10002];
|
|
let _Array = Array;
|
|
let arr2 = tmp5;
|
|
if (!Array.isArray(tmp5)) {
|
|
let items = [tmp5];
|
|
arr2 = items;
|
|
}
|
|
let item = arr2.forEach((attributes) => {
|
|
obj = ParseError(5294);
|
|
obj.objectAssign(obj, parseNodeAttributesAsTags(attributes.attributes));
|
|
if (typeof attributes.value === "object") {
|
|
ParseError(5294).objectAssign(obj, parseNodeChildrenAsTags(attributes.value));
|
|
const tmpResult = ParseError(5294);
|
|
}
|
|
});
|
|
continue;
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
function parseNodeAttributesAsTags(attributes) {
|
|
const obj = {};
|
|
for (const key10005 in arg0) {
|
|
try {
|
|
if (isTagAttribute(key10005)) {
|
|
let obj2 = { value: arg0[key10005], attributes: {}, description: null };
|
|
let tmp3 = getLocalName(key10005);
|
|
obj2.description = getDescription(arg0[key10005], key10005);
|
|
obj[tmp3] = obj2;
|
|
}
|
|
continue;
|
|
} catch (err) {
|
|
continue;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function isTagAttribute(key10005) {
|
|
let tmp = "rdf:parseType" !== key10005;
|
|
if (tmp) {
|
|
tmp = "xmlns" !== key10005.split(":")[0];
|
|
}
|
|
return tmp;
|
|
}
|
|
function isNamespaceDefinition(key10005) {
|
|
return "xmlns" === key10005.split(":")[0];
|
|
}
|
|
function getLocalName(key10005) {
|
|
let str = "RatingPercent";
|
|
if (!obj.test(key10005)) {
|
|
str = key10005.split(":")[1];
|
|
}
|
|
return str;
|
|
}
|
|
function getDescription(arr) {
|
|
if (Array.isArray(arr)) {
|
|
const tmp11 = (function getDescriptionOfArray(arr) {
|
|
const mapped = arr.map((value) => {
|
|
if (undefined !== value.value) {
|
|
let tmp2 = closure_1_18(value.value);
|
|
} else {
|
|
tmp2 = closure_1_18(value);
|
|
}
|
|
return tmp2;
|
|
});
|
|
return mapped.join(", ");
|
|
})(arr);
|
|
let tmp12 = tmp11;
|
|
if (tmp2) {
|
|
tmp12 = tmp11;
|
|
if (typeof calculateGPSValueDefault[tmp2] === "function") {
|
|
tmp12 = tmp13(5332)[tmp2](arr, tmp11);
|
|
const tmp13Result = tmp13(5332);
|
|
}
|
|
tmp13 = importDefault;
|
|
}
|
|
return tmp12;
|
|
} else if (typeof arr === "object") {
|
|
return (function getDescriptionOfObject(arr) {
|
|
const items = [];
|
|
for (const key10024 in arg0) {
|
|
let str8 = "CreatorCity";
|
|
if ("CiAdrCity" !== key10024) {
|
|
let str = "CreatorCountry";
|
|
if ("CiAdrCtry" !== key10024) {
|
|
let str2 = "CreatorAddress";
|
|
if ("CiAdrExtadr" !== key10024) {
|
|
let str3 = "CreatorPostalCode";
|
|
if ("CiAdrPcode" !== key10024) {
|
|
let str4 = "CreatorRegion";
|
|
if ("CiAdrRegion" !== key10024) {
|
|
let str5 = "CreatorWorkEmail";
|
|
if ("CiEmailWork" !== key10024) {
|
|
let str6 = "CreatorWorkPhone";
|
|
if ("CiTelWork" !== key10024) {
|
|
let str7 = "CreatorWorkUrl";
|
|
if ("CiUrlWork" !== key10024) {
|
|
str7 = key10024;
|
|
}
|
|
str6 = str7;
|
|
}
|
|
str5 = str6;
|
|
}
|
|
str4 = str5;
|
|
}
|
|
str3 = str4;
|
|
}
|
|
str2 = str3;
|
|
}
|
|
str = str2;
|
|
}
|
|
str8 = str;
|
|
}
|
|
let _HermesInternal = HermesInternal;
|
|
arr = items.push("" + str8 + ": " + getDescription(arg0[key10024].value));
|
|
continue;
|
|
}
|
|
return items.join("; ");
|
|
})(arr);
|
|
} else {
|
|
try {
|
|
if (tmp2) {
|
|
if (typeof calculateGPSValueDefault[tmp2] === "function") {
|
|
let decodeURIComponentResult = calculateGPSValueDefault[tmp2](arr);
|
|
const tmp4Result = calculateGPSValueDefault;
|
|
}
|
|
return decodeURIComponentResult;
|
|
}
|
|
const _decodeURIComponent = decodeURIComponent;
|
|
const _escape = escape;
|
|
decodeURIComponentResult = decodeURIComponent(escape(arr));
|
|
} catch (err) {
|
|
return tmp;
|
|
}
|
|
}
|
|
}
|
|
function parseNodeChildrenAsTags(value) {
|
|
const obj = {};
|
|
for (const key10005 in arg0) {
|
|
try {
|
|
if (!isNamespaceDefinition(key10005)) {
|
|
let tmp3 = getLocalName(key10005);
|
|
obj[tmp3] = parseNodeAsTag(arg0[key10005], key10005);
|
|
}
|
|
continue;
|
|
} catch (err) {
|
|
continue;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function parseNodeAsTag(attributes, key10005) {
|
|
if (Array.isArray(attributes)) {
|
|
let tmp9 = parseNodeAsSimpleValue(attributes[attributes.length - 1], key10005);
|
|
} else {
|
|
let tmp = "Resource" === attributes.attributes["rdf:parseType"] && typeof attributes.value === "string";
|
|
if (tmp) {
|
|
tmp = "" === attributes.value.trim();
|
|
}
|
|
if (tmp) {
|
|
const obj3 = { value: "", attributes: {}, description: "" };
|
|
tmp9 = obj3;
|
|
} else {
|
|
let tmp2 = "Resource" === attributes.attributes["rdf:parseType"];
|
|
if (tmp2) {
|
|
tmp2 = undefined !== attributes.value["rdf:value"];
|
|
}
|
|
if (!tmp2) {
|
|
tmp2 = undefined !== attributes.value["rdf:Description"] && undefined !== attributes.value["rdf:Description"].value["rdf:value"];
|
|
let tmp3 = undefined !== attributes.value["rdf:Description"] && undefined !== attributes.value["rdf:Description"].value["rdf:value"];
|
|
}
|
|
if (tmp2) {
|
|
tmp9 = parseNodeAsSimpleRdfDescription(attributes, key10005);
|
|
} else {
|
|
let tmp4 = "Resource" === attributes.attributes["rdf:parseType"];
|
|
if (!tmp4) {
|
|
tmp4 = undefined !== attributes.value["rdf:Description"] && undefined === attributes.value["rdf:Description"].value["rdf:value"];
|
|
let tmp5 = undefined !== attributes.value["rdf:Description"] && undefined === attributes.value["rdf:Description"].value["rdf:value"];
|
|
}
|
|
if (tmp4) {
|
|
tmp9 = parseNodeAsStructureRdfDescription(attributes, key10005);
|
|
} else {
|
|
let _Object = Object;
|
|
let tmp6 = 0 === Object.keys(attributes.value).length;
|
|
if (tmp6) {
|
|
tmp6 = undefined === attributes.attributes["xml:lang"];
|
|
}
|
|
if (tmp6) {
|
|
tmp6 = undefined === attributes.attributes["rdf:resource"];
|
|
}
|
|
if (tmp6) {
|
|
const tmp16 = parseNodeAttributesAsTags(attributes.attributes);
|
|
const obj4 = { value: tmp16, attributes: {}, description: getDescription(tmp16, key10005) };
|
|
tmp9 = obj4;
|
|
} else {
|
|
value = attributes.value;
|
|
if (undefined !== tmp7) {
|
|
value2 = attributes.value;
|
|
const prop = value2["rdf:Bag"] || value2["rdf:Seq"] || value2["rdf:Alt"].value["rdf:li"];
|
|
let obj = {};
|
|
for (const key10070 in arg0.attributes) {
|
|
let tmp11 = "rdf:parseType" === key10070;
|
|
if (!tmp11) {
|
|
tmp11 = "rdf:resource" === key10070;
|
|
}
|
|
if (!tmp11) {
|
|
tmp11 = "xmlns" === key10070.split(":")[0];
|
|
}
|
|
if (tmp11) {
|
|
continue;
|
|
} else {
|
|
let obj2 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str9 = "RatingPercent";
|
|
if (!obj2.test(key10070)) {
|
|
str9 = key10070.split(":")[1];
|
|
}
|
|
obj[str9] = arg0.attributes[key10070];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
const items = [];
|
|
if (undefined === prop) {
|
|
let items1 = [];
|
|
} else {
|
|
const _Array = Array;
|
|
items1 = prop;
|
|
if (!Array.isArray(prop)) {
|
|
const items2 = [prop];
|
|
items1 = items2;
|
|
}
|
|
}
|
|
const item = items1.forEach((attributes) => {
|
|
let tmp2 = "Resource" === attributes.attributes["rdf:parseType"];
|
|
if (tmp2) {
|
|
tmp2 = undefined !== attributes.value["rdf:value"];
|
|
}
|
|
if (!tmp2) {
|
|
tmp2 = undefined !== attributes.value["rdf:Description"] && undefined !== attributes.value["rdf:Description"].value["rdf:value"];
|
|
const tmp3 = undefined !== attributes.value["rdf:Description"] && undefined !== attributes.value["rdf:Description"].value["rdf:value"];
|
|
}
|
|
if (tmp2) {
|
|
value = parseNodeAsSimpleRdfDescription(attributes);
|
|
} else {
|
|
let tmp4 = "Resource" === attributes.attributes["rdf:parseType"];
|
|
if (!tmp4) {
|
|
tmp4 = undefined !== attributes.value["rdf:Description"] && undefined === attributes.value["rdf:Description"].value["rdf:value"];
|
|
const tmp5 = undefined !== attributes.value["rdf:Description"] && undefined === attributes.value["rdf:Description"].value["rdf:value"];
|
|
}
|
|
if (tmp4) {
|
|
value = parseNodeAsStructureRdfDescription(attributes).value;
|
|
} else {
|
|
const _Object = Object;
|
|
let tmp7 = 0 === Object.keys(attributes.value).length;
|
|
if (tmp7) {
|
|
tmp7 = undefined === attributes.attributes["xml:lang"];
|
|
}
|
|
if (tmp7) {
|
|
tmp7 = undefined === attributes.attributes["rdf:resource"];
|
|
}
|
|
if (tmp7) {
|
|
const tmp10 = parseNodeAttributesAsTags(attributes.attributes);
|
|
getDescription(tmp10, undefined);
|
|
value = tmp10;
|
|
} else {
|
|
value = parseNodeAsSimpleValue(attributes);
|
|
}
|
|
}
|
|
}
|
|
items.push(value);
|
|
});
|
|
const obj5 = { value: items, attributes: obj, description: null };
|
|
obj = getDescription(items, key10005);
|
|
obj5.description = obj;
|
|
const iter = value2["rdf:Bag"] || value2["rdf:Seq"] || value2["rdf:Alt"];
|
|
} else {
|
|
tmp9 = parseNodeAsSimpleValue(attributes, key10005);
|
|
}
|
|
tmp7 = value["rdf:Bag"] || value["rdf:Seq"] || value["rdf:Alt"];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return tmp9;
|
|
}
|
|
function parseNodeAsSimpleRdfDescription(attributes, key10005) {
|
|
const obj = {};
|
|
for (const key10009 in arg0.attributes) {
|
|
let tmp = "rdf:parseType" === key10009;
|
|
if (!tmp) {
|
|
tmp = "rdf:resource" === key10009;
|
|
}
|
|
if (!tmp) {
|
|
tmp = "xmlns" === key10009.split(":")[0];
|
|
}
|
|
if (tmp) {
|
|
continue;
|
|
} else {
|
|
let obj2 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str = "RatingPercent";
|
|
if (!obj2.test(key10009)) {
|
|
str = key10009.split(":")[1];
|
|
}
|
|
obj[str] = arg0.attributes[key10009];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
let iter = attributes;
|
|
if (undefined !== attributes.value["rdf:Description"]) {
|
|
iter = attributes.value["rdf:Description"];
|
|
}
|
|
const obj4 = {};
|
|
for (const key10035 in iter.attributes) {
|
|
let tmp2 = "rdf:parseType" === key10035;
|
|
if (!tmp2) {
|
|
tmp2 = "rdf:resource" === key10035;
|
|
}
|
|
if (!tmp2) {
|
|
tmp2 = "xmlns" === key10035.split(":")[0];
|
|
}
|
|
if (tmp2) {
|
|
continue;
|
|
} else {
|
|
let obj5 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str2 = "RatingPercent";
|
|
if (!obj5.test(key10035)) {
|
|
str2 = key10035.split(":")[1];
|
|
}
|
|
obj4[str2] = iter.attributes[key10035];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
const obj6 = {};
|
|
for (const key10052 in iter.value) {
|
|
let tmp3 = "rdf:value" === key10052;
|
|
if (!tmp3) {
|
|
tmp3 = "xmlns" === key10052.split(":")[0];
|
|
}
|
|
if (tmp3) {
|
|
continue;
|
|
} else {
|
|
let obj7 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str3 = "RatingPercent";
|
|
if (!obj7.test(key10052)) {
|
|
str3 = key10052.split(":")[1];
|
|
}
|
|
obj6[str3] = iter.value[key10052].value;
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
ParseError(5294).objectAssign(obj, obj4, obj6);
|
|
const prop = iter.value["rdf:value"];
|
|
const obj3 = ParseError(5294);
|
|
return { value: prop.attributes && prop.attributes["rdf:resource"] || iter.value["rdf:value"].value, attributes: obj, description: getDescription(prop.attributes && prop.attributes["rdf:resource"] || iter.value["rdf:value"].value, key10005) };
|
|
}
|
|
function parseNodeAsStructureRdfDescription(value, key10005) {
|
|
const obj = { value: {}, attributes: {} };
|
|
let iter = value;
|
|
if (undefined !== value.value["rdf:Description"]) {
|
|
ParseError(5294).objectAssign(obj.value, parseNodeAttributesAsTags(value.value["rdf:Description"].attributes));
|
|
const obj4 = ParseError(5294);
|
|
const obj6 = {};
|
|
for (const key10008 in arg0.attributes) {
|
|
let tmp = "rdf:parseType" === key10008;
|
|
if (!tmp) {
|
|
tmp = "rdf:resource" === key10008;
|
|
}
|
|
if (!tmp) {
|
|
tmp = "xmlns" === key10008.split(":")[0];
|
|
}
|
|
if (tmp) {
|
|
continue;
|
|
} else {
|
|
let obj2 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str = "RatingPercent";
|
|
if (!obj2.test(key10008)) {
|
|
str = key10008.split(":")[1];
|
|
}
|
|
obj6[str] = arg0.attributes[key10008];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
ParseError(5294).objectAssign(obj.attributes, obj6);
|
|
iter = value.value["rdf:Description"];
|
|
const obj5 = ParseError(5294);
|
|
}
|
|
ParseError(5294).objectAssign(obj.value, parseNodeChildrenAsTags(iter.value));
|
|
obj.description = getDescription(obj.value, key10005);
|
|
return obj;
|
|
}
|
|
function parseNodeAsSimpleValue(attributes, key10005) {
|
|
let tmp2 = attributes.attributes && attributes.attributes["rdf:resource"];
|
|
if (!tmp2) {
|
|
value = attributes.value;
|
|
let obj = {};
|
|
let tmp3 = value;
|
|
if (typeof value !== "string") {
|
|
tmp3 = obj;
|
|
const keys = Object.keys();
|
|
if (keys !== undefined) {
|
|
tmp3 = obj;
|
|
while (keys[tmp] !== undefined) {
|
|
let tmp11 = value[tmp4];
|
|
let _Array = Array;
|
|
let arr2 = tmp11;
|
|
if (!Array.isArray(tmp11)) {
|
|
let items = [tmp11];
|
|
arr2 = items;
|
|
}
|
|
let item = arr2.forEach((attributes) => {
|
|
obj = ParseError(5294);
|
|
obj.objectAssign(obj, parseNodeAttributesAsTags(attributes.attributes));
|
|
if (typeof attributes.value === "object") {
|
|
ParseError(5294).objectAssign(obj, parseNodeChildrenAsTags(attributes.value));
|
|
const tmpResult = ParseError(5294);
|
|
}
|
|
});
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
tmp2 = tmp3;
|
|
}
|
|
const obj2 = { value: tmp2, attributes: null, description: null };
|
|
const obj3 = {};
|
|
for (const key10021 in arg0.attributes) {
|
|
let tmp6 = "rdf:parseType" === key10021;
|
|
if (!tmp6) {
|
|
tmp6 = "rdf:resource" === key10021;
|
|
}
|
|
if (!tmp6) {
|
|
tmp6 = "xmlns" === key10021.split(":")[0];
|
|
}
|
|
if (tmp6) {
|
|
continue;
|
|
} else {
|
|
let obj4 = /^MicrosoftPhoto(_\d+_)?:Rating$/i;
|
|
let str = "RatingPercent";
|
|
if (!obj4.test(key10021)) {
|
|
str = key10021.split(":")[1];
|
|
}
|
|
obj3[str] = arg0.attributes[key10021];
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
obj2.attributes = obj3;
|
|
obj2.description = getDescription(tmp2, key10005);
|
|
return obj2;
|
|
}
|
|
class ParseError {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = closure_4(this, ParseError);
|
|
items = [];
|
|
items[0] = global;
|
|
tmp2 = metroRequire;
|
|
obj = metroRequire(ParseError);
|
|
tmp3 = hasOwnProperty;
|
|
if (closure_7()) {
|
|
tmp5 = globalThis;
|
|
_Reflect = Reflect;
|
|
constructResult = Reflect.construct(obj, items, tmp2(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp3Result = tmp3(self, constructResult);
|
|
tmp3Result.name = "ParseError";
|
|
return tmp3Result;
|
|
}
|
|
}
|
|
_inherits(ParseError, _wrapNativeSuperDefault(Error));
|
|
let closure_8 = _createClass(ParseError);
|
|
|
|
export default {
|
|
read(buffer, arr, arg2) {
|
|
let length;
|
|
let length2;
|
|
let length3;
|
|
const obj = {};
|
|
if (typeof buffer === "string") {
|
|
readTags(obj, buffer, arg2);
|
|
return obj;
|
|
} else {
|
|
if (0 === arr.length) {
|
|
let items = [];
|
|
} else {
|
|
const substr = arr.slice(0, 1);
|
|
const _Uint8Array5 = Uint8Array;
|
|
const uint8Array = new Uint8Array(substr.reduce((acc, item) => acc + item.length, 0));
|
|
let num2 = 0;
|
|
let num = 0;
|
|
if (0 < substr.length) {
|
|
do {
|
|
arr = substr[num2];
|
|
buffer = buffer.buffer;
|
|
let _Uint8Array = Uint8Array;
|
|
let tmp3 = new.target;
|
|
let tmp4 = new.target;
|
|
let uint8Array1 = new Uint8Array(buffer.slice(arr.dataOffset, arr.dataOffset + arr.length));
|
|
let result = uint8Array.set(uint8Array1, num);
|
|
num = num + arr.length;
|
|
num2 = num2 + 1;
|
|
length = substr.length;
|
|
} while (num2 < length);
|
|
}
|
|
const _DataView = DataView;
|
|
const dataView = new DataView(uint8Array.buffer);
|
|
const items1 = [dataView];
|
|
items = items1;
|
|
if (arr.length > 1) {
|
|
const substr1 = arr.slice(1);
|
|
const _Uint8Array6 = Uint8Array;
|
|
const uint8Array2 = new Uint8Array(substr1.reduce((acc, item) => acc + item.length, 0));
|
|
let num4 = 0;
|
|
let num3 = 0;
|
|
if (0 < substr1.length) {
|
|
do {
|
|
let arr5 = substr1[num4];
|
|
let buffer1 = buffer.buffer;
|
|
let _Uint8Array2 = Uint8Array;
|
|
let tmp12 = new.target;
|
|
let tmp13 = new.target;
|
|
let uint8Array3 = new Uint8Array(buffer1.slice(arr5.dataOffset, arr5.dataOffset + arr5.length));
|
|
let result1 = uint8Array2.set(uint8Array3, num3);
|
|
num3 = num3 + arr5.length;
|
|
num4 = num4 + 1;
|
|
length2 = substr1.length;
|
|
} while (num4 < length2);
|
|
}
|
|
const _DataView2 = DataView;
|
|
const dataView1 = new DataView(uint8Array2.buffer);
|
|
items1.push(dataView1);
|
|
items = items1;
|
|
}
|
|
}
|
|
const tmp23 = _slicedToArray(items, 2);
|
|
let tmp25Result = readTags(obj, tmp23[0], arg2);
|
|
if (tmp23[1]) {
|
|
if (!tmp25Result) {
|
|
tmp25Result = tmp25(obj, tmp24, arg2);
|
|
}
|
|
if (!tmp25Result) {
|
|
delete tmp[tmp2];
|
|
const _Uint8Array3 = Uint8Array;
|
|
const uint8Array4 = new Uint8Array(arr.reduce((acc, item) => acc + item.length, 0));
|
|
let num7 = 0;
|
|
let num8 = 0;
|
|
if (0 < arr.length) {
|
|
do {
|
|
let arr7 = arr[num7];
|
|
let buffer2 = buffer.buffer;
|
|
let _Uint8Array4 = Uint8Array;
|
|
let tmp31 = new.target;
|
|
let tmp32 = new.target;
|
|
let uint8Array5 = new Uint8Array(buffer2.slice(arr7.dataOffset, arr7.dataOffset + arr7.length));
|
|
let result2 = uint8Array4.set(uint8Array5, num8);
|
|
num8 = num8 + arr7.length;
|
|
num7 = num7 + 1;
|
|
length3 = arr.length;
|
|
} while (num7 < length3);
|
|
}
|
|
const _DataView3 = DataView;
|
|
const dataView2 = new DataView(uint8Array4.buffer);
|
|
tmp25(obj, dataView2, arg2);
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
};
|