feedsmith 2.0.0 → 2.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -4
- package/dist/index.cjs +3619 -0
- package/dist/index.d.cts +1016 -0
- package/dist/index.d.ts +1016 -19
- package/dist/index.js +3581 -14
- package/package.json +19 -11
- package/dist/common/config.d.ts +0 -23
- package/dist/common/config.js +0 -43
- package/dist/common/parse.d.ts +0 -19
- package/dist/common/parse.js +0 -24
- package/dist/common/types.d.ts +0 -41
- package/dist/common/types.js +0 -1
- package/dist/common/utils.d.ts +0 -37
- package/dist/common/utils.js +0 -477
- package/dist/feeds/atom/common/types.d.ts +0 -103
- package/dist/feeds/atom/common/types.js +0 -2
- package/dist/feeds/atom/detect/index.d.ts +0 -1
- package/dist/feeds/atom/detect/index.js +0 -13
- package/dist/feeds/atom/generate/config.d.ts +0 -2
- package/dist/feeds/atom/generate/config.js +0 -5
- package/dist/feeds/atom/generate/index.d.ts +0 -3
- package/dist/feeds/atom/generate/index.js +0 -10
- package/dist/feeds/atom/generate/utils.d.ts +0 -11
- package/dist/feeds/atom/generate/utils.js +0 -181
- package/dist/feeds/atom/parse/config.d.ts +0 -3
- package/dist/feeds/atom/parse/config.js +0 -68
- package/dist/feeds/atom/parse/index.d.ts +0 -3
- package/dist/feeds/atom/parse/index.js +0 -18
- package/dist/feeds/atom/parse/utils.d.ts +0 -16
- package/dist/feeds/atom/parse/utils.js +0 -206
- package/dist/feeds/json/common/types.d.ts +0 -53
- package/dist/feeds/json/common/types.js +0 -2
- package/dist/feeds/json/detect/index.d.ts +0 -1
- package/dist/feeds/json/detect/index.js +0 -16
- package/dist/feeds/json/generate/index.d.ts +0 -3
- package/dist/feeds/json/generate/index.js +0 -4
- package/dist/feeds/json/generate/utils.d.ts +0 -1971
- package/dist/feeds/json/generate/utils.js +0 -17
- package/dist/feeds/json/parse/index.d.ts +0 -3
- package/dist/feeds/json/parse/index.js +0 -13
- package/dist/feeds/json/parse/utils.d.ts +0 -9
- package/dist/feeds/json/parse/utils.js +0 -114
- package/dist/feeds/rdf/common/types.d.ts +0 -48
- package/dist/feeds/rdf/common/types.js +0 -2
- package/dist/feeds/rdf/detect/index.d.ts +0 -1
- package/dist/feeds/rdf/detect/index.js +0 -14
- package/dist/feeds/rdf/parse/config.d.ts +0 -3
- package/dist/feeds/rdf/parse/config.js +0 -22
- package/dist/feeds/rdf/parse/index.d.ts +0 -3
- package/dist/feeds/rdf/parse/index.js +0 -18
- package/dist/feeds/rdf/parse/utils.d.ts +0 -10
- package/dist/feeds/rdf/parse/utils.js +0 -90
- package/dist/feeds/rss/common/types.d.ts +0 -111
- package/dist/feeds/rss/common/types.js +0 -2
- package/dist/feeds/rss/detect/index.d.ts +0 -1
- package/dist/feeds/rss/detect/index.js +0 -13
- package/dist/feeds/rss/generate/config.d.ts +0 -2
- package/dist/feeds/rss/generate/config.js +0 -5
- package/dist/feeds/rss/generate/index.d.ts +0 -3
- package/dist/feeds/rss/generate/index.js +0 -10
- package/dist/feeds/rss/generate/utils.d.ts +0 -14
- package/dist/feeds/rss/generate/utils.js +0 -181
- package/dist/feeds/rss/parse/config.d.ts +0 -3
- package/dist/feeds/rss/parse/config.js +0 -49
- package/dist/feeds/rss/parse/index.d.ts +0 -3
- package/dist/feeds/rss/parse/index.js +0 -18
- package/dist/feeds/rss/parse/utils.d.ts +0 -15
- package/dist/feeds/rss/parse/utils.js +0 -163
- package/dist/namespaces/atom/common/types.d.ts +0 -4
- package/dist/namespaces/atom/common/types.js +0 -2
- package/dist/namespaces/atom/generate/utils.d.ts +0 -4
- package/dist/namespaces/atom/generate/utils.js +0 -7
- package/dist/namespaces/atom/parse/utils.d.ts +0 -4
- package/dist/namespaces/atom/parse/utils.js +0 -7
- package/dist/namespaces/content/common/types.d.ts +0 -3
- package/dist/namespaces/content/common/types.js +0 -2
- package/dist/namespaces/content/generate/utils.d.ts +0 -3
- package/dist/namespaces/content/generate/utils.js +0 -10
- package/dist/namespaces/content/parse/utils.d.ts +0 -3
- package/dist/namespaces/content/parse/utils.js +0 -10
- package/dist/namespaces/dc/common/types.d.ts +0 -18
- package/dist/namespaces/dc/common/types.js +0 -2
- package/dist/namespaces/dc/generate/utils.d.ts +0 -3
- package/dist/namespaces/dc/generate/utils.js +0 -24
- package/dist/namespaces/dc/parse/utils.d.ts +0 -3
- package/dist/namespaces/dc/parse/utils.js +0 -24
- package/dist/namespaces/dcterms/common/types.d.ts +0 -58
- package/dist/namespaces/dcterms/common/types.js +0 -2
- package/dist/namespaces/dcterms/generate/utils.d.ts +0 -3
- package/dist/namespaces/dcterms/generate/utils.js +0 -64
- package/dist/namespaces/dcterms/parse/utils.d.ts +0 -3
- package/dist/namespaces/dcterms/parse/utils.js +0 -64
- package/dist/namespaces/georss/common/types.d.ts +0 -26
- package/dist/namespaces/georss/common/types.js +0 -2
- package/dist/namespaces/georss/generate/utils.d.ts +0 -11
- package/dist/namespaces/georss/generate/utils.js +0 -60
- package/dist/namespaces/georss/parse/utils.d.ts +0 -11
- package/dist/namespaces/georss/parse/utils.js +0 -68
- package/dist/namespaces/itunes/common/types.d.ts +0 -44
- package/dist/namespaces/itunes/common/types.js +0 -2
- package/dist/namespaces/itunes/generate/utils.d.ts +0 -7
- package/dist/namespaces/itunes/generate/utils.js +0 -70
- package/dist/namespaces/itunes/parse/utils.d.ts +0 -9
- package/dist/namespaces/itunes/parse/utils.js +0 -99
- package/dist/namespaces/media/common/types.d.ts +0 -172
- package/dist/namespaces/media/common/types.js +0 -2
- package/dist/namespaces/media/generate/utils.d.ts +0 -33
- package/dist/namespaces/media/generate/utils.js +0 -350
- package/dist/namespaces/media/parse/utils.d.ts +0 -35
- package/dist/namespaces/media/parse/utils.js +0 -344
- package/dist/namespaces/podcast/common/types.d.ts +0 -182
- package/dist/namespaces/podcast/common/types.js +0 -2
- package/dist/namespaces/podcast/generate/utils.d.ts +0 -32
- package/dist/namespaces/podcast/generate/utils.js +0 -362
- package/dist/namespaces/podcast/parse/utils.d.ts +0 -31
- package/dist/namespaces/podcast/parse/utils.js +0 -330
- package/dist/namespaces/slash/common/types.d.ts +0 -7
- package/dist/namespaces/slash/common/types.js +0 -2
- package/dist/namespaces/slash/generate/utils.d.ts +0 -3
- package/dist/namespaces/slash/generate/utils.js +0 -13
- package/dist/namespaces/slash/parse/utils.d.ts +0 -4
- package/dist/namespaces/slash/parse/utils.js +0 -16
- package/dist/namespaces/sy/common/types.d.ts +0 -6
- package/dist/namespaces/sy/common/types.js +0 -2
- package/dist/namespaces/sy/generate/utils.d.ts +0 -3
- package/dist/namespaces/sy/generate/utils.js +0 -12
- package/dist/namespaces/sy/parse/utils.d.ts +0 -3
- package/dist/namespaces/sy/parse/utils.js +0 -12
- package/dist/namespaces/thr/common/types.d.ts +0 -15
- package/dist/namespaces/thr/common/types.js +0 -2
- package/dist/namespaces/thr/generate/utils.d.ts +0 -5
- package/dist/namespaces/thr/generate/utils.js +0 -33
- package/dist/namespaces/thr/parse/utils.d.ts +0 -5
- package/dist/namespaces/thr/parse/utils.js +0 -33
- package/dist/namespaces/wfw/common/types.d.ts +0 -4
- package/dist/namespaces/wfw/common/types.js +0 -2
- package/dist/namespaces/wfw/generate/utils.d.ts +0 -3
- package/dist/namespaces/wfw/generate/utils.js +0 -11
- package/dist/namespaces/wfw/parse/utils.d.ts +0 -3
- package/dist/namespaces/wfw/parse/utils.js +0 -11
- package/dist/namespaces/yt/common/types.d.ts +0 -8
- package/dist/namespaces/yt/common/types.js +0 -2
- package/dist/namespaces/yt/generate/utils.d.ts +0 -4
- package/dist/namespaces/yt/generate/utils.js +0 -21
- package/dist/namespaces/yt/parse/utils.d.ts +0 -4
- package/dist/namespaces/yt/parse/utils.js +0 -21
- package/dist/opml/common/types.d.ts +0 -39
- package/dist/opml/common/types.js +0 -2
- package/dist/opml/generate/config.d.ts +0 -2
- package/dist/opml/generate/config.js +0 -5
- package/dist/opml/generate/index.d.ts +0 -3
- package/dist/opml/generate/index.js +0 -10
- package/dist/opml/generate/utils.d.ts +0 -6
- package/dist/opml/generate/utils.js +0 -66
- package/dist/opml/parse/config.d.ts +0 -3
- package/dist/opml/parse/config.js +0 -22
- package/dist/opml/parse/index.d.ts +0 -3
- package/dist/opml/parse/index.js +0 -10
- package/dist/opml/parse/utils.d.ts +0 -6
- package/dist/opml/parse/utils.js +0 -63
package/dist/index.js
CHANGED
|
@@ -1,14 +1,3581 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
1
|
+
import { decodeHTML, decodeXML } from "entities";
|
|
2
|
+
import { XMLBuilder, XMLParser } from "fast-xml-parser";
|
|
3
|
+
|
|
4
|
+
//#region src/common/utils.ts
|
|
5
|
+
const isPresent = (value) => {
|
|
6
|
+
return value != null;
|
|
7
|
+
};
|
|
8
|
+
const isObject = (value) => {
|
|
9
|
+
return value != null && typeof value === "object" && !Array.isArray(value) && value.constructor === Object;
|
|
10
|
+
};
|
|
11
|
+
const whitespaceOnlyRegex = /^\p{White_Space}*$/u;
|
|
12
|
+
const isNonEmptyString = (value) => {
|
|
13
|
+
return typeof value === "string" && value !== "" && !whitespaceOnlyRegex.test(value);
|
|
14
|
+
};
|
|
15
|
+
const isNonEmptyStringOrNumber = (value) => {
|
|
16
|
+
return typeof value === "number" || isNonEmptyString(value);
|
|
17
|
+
};
|
|
18
|
+
const retrieveText = (value) => {
|
|
19
|
+
return value?.["#text"] ?? value;
|
|
20
|
+
};
|
|
21
|
+
const trimObject = (object) => {
|
|
22
|
+
let result;
|
|
23
|
+
for (const key in object) {
|
|
24
|
+
const value = object[key];
|
|
25
|
+
if (isPresent(value)) {
|
|
26
|
+
if (!result) result = {};
|
|
27
|
+
result[key] = value;
|
|
28
|
+
}
|
|
29
|
+
}
|
|
30
|
+
return result;
|
|
31
|
+
};
|
|
32
|
+
const trimArray = (value, parse$6) => {
|
|
33
|
+
if (!Array.isArray(value) || value.length === 0) return;
|
|
34
|
+
if (!parse$6) {
|
|
35
|
+
let needsTrimming = false;
|
|
36
|
+
for (let i = 0; i < value.length; i++) if (!isPresent(value[i])) {
|
|
37
|
+
needsTrimming = true;
|
|
38
|
+
break;
|
|
39
|
+
}
|
|
40
|
+
if (!needsTrimming) return value;
|
|
41
|
+
}
|
|
42
|
+
const result = [];
|
|
43
|
+
for (let i = 0; i < value.length; i++) {
|
|
44
|
+
const item = parse$6 ? parse$6(value[i]) : value[i];
|
|
45
|
+
if (isPresent(item)) result.push(item);
|
|
46
|
+
}
|
|
47
|
+
return result.length > 0 ? result : void 0;
|
|
48
|
+
};
|
|
49
|
+
const cdataStartTag = "<![CDATA[";
|
|
50
|
+
const cdataEndTag = "]]>";
|
|
51
|
+
const stripCdata = (text) => {
|
|
52
|
+
if (typeof text !== "string") return text;
|
|
53
|
+
let currentIndex = text.indexOf(cdataStartTag);
|
|
54
|
+
if (currentIndex === -1) return text;
|
|
55
|
+
let result = "";
|
|
56
|
+
let lastIndex = 0;
|
|
57
|
+
while (currentIndex !== -1) {
|
|
58
|
+
result += text.substring(lastIndex, currentIndex);
|
|
59
|
+
lastIndex = text.indexOf(cdataEndTag, currentIndex + 9);
|
|
60
|
+
if (lastIndex === -1) return text;
|
|
61
|
+
result += text.substring(currentIndex + 9, lastIndex);
|
|
62
|
+
lastIndex += 3;
|
|
63
|
+
currentIndex = text.indexOf(cdataStartTag, lastIndex);
|
|
64
|
+
}
|
|
65
|
+
result += text.substring(lastIndex);
|
|
66
|
+
return result;
|
|
67
|
+
};
|
|
68
|
+
const hasEntities = (text) => {
|
|
69
|
+
const ampIndex = text.indexOf("&");
|
|
70
|
+
return ampIndex !== -1 && text.indexOf(";", ampIndex) !== -1;
|
|
71
|
+
};
|
|
72
|
+
const parseString = (value) => {
|
|
73
|
+
if (typeof value === "string") {
|
|
74
|
+
if (value === "") return;
|
|
75
|
+
let string = value;
|
|
76
|
+
if (value.indexOf(cdataStartTag) !== -1) string = stripCdata(value);
|
|
77
|
+
string = string.trim();
|
|
78
|
+
if (string === "") return;
|
|
79
|
+
if (hasEntities(string)) {
|
|
80
|
+
string = decodeXML(string);
|
|
81
|
+
if (hasEntities(string)) string = decodeHTML(string);
|
|
82
|
+
}
|
|
83
|
+
return string || void 0;
|
|
84
|
+
}
|
|
85
|
+
if (typeof value === "number") return value.toString();
|
|
86
|
+
};
|
|
87
|
+
const parseNumber = (value) => {
|
|
88
|
+
if (typeof value === "number") return value;
|
|
89
|
+
if (isNonEmptyString(value)) {
|
|
90
|
+
const numeric = +value;
|
|
91
|
+
return Number.isNaN(numeric) ? void 0 : numeric;
|
|
92
|
+
}
|
|
93
|
+
};
|
|
94
|
+
const trueRegex = /^\p{White_Space}*true\p{White_Space}*$/iu;
|
|
95
|
+
const falseRegex = /^\p{White_Space}*false\p{White_Space}*$/iu;
|
|
96
|
+
const yesRegex = /^\p{White_Space}*yes\p{White_Space}*$/iu;
|
|
97
|
+
const parseBoolean = (value) => {
|
|
98
|
+
if (typeof value === "boolean") return value;
|
|
99
|
+
if (isNonEmptyString(value)) {
|
|
100
|
+
if (trueRegex.test(value)) return true;
|
|
101
|
+
if (falseRegex.test(value)) return false;
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
const parseYesNoBoolean = (value) => {
|
|
105
|
+
const boolean = parseBoolean(value);
|
|
106
|
+
if (boolean !== void 0) return boolean;
|
|
107
|
+
if (isNonEmptyString(value)) return yesRegex.test(value);
|
|
108
|
+
};
|
|
109
|
+
const parseDate = (value) => {
|
|
110
|
+
return parseString(value);
|
|
111
|
+
};
|
|
112
|
+
const parseArray = (value) => {
|
|
113
|
+
if (Array.isArray(value)) return value;
|
|
114
|
+
if (!isObject(value)) return;
|
|
115
|
+
if (value.length) return Array.from(value);
|
|
116
|
+
const keys = Object.keys(value);
|
|
117
|
+
if (keys.length === 0) return;
|
|
118
|
+
for (let i = 0; i < keys.length; i++) {
|
|
119
|
+
const key = keys[i];
|
|
120
|
+
const n = Number(key);
|
|
121
|
+
if (!Number.isInteger(n) || n !== i) return;
|
|
122
|
+
}
|
|
123
|
+
return Object.values(value);
|
|
124
|
+
};
|
|
125
|
+
const parseArrayOf = (value, parse$6) => {
|
|
126
|
+
const array = parseArray(value);
|
|
127
|
+
if (array) return trimArray(array, parse$6);
|
|
128
|
+
const parsed = parse$6(value);
|
|
129
|
+
if (parsed) return [parsed];
|
|
130
|
+
};
|
|
131
|
+
const parseSingular = (value) => {
|
|
132
|
+
return Array.isArray(value) ? value[0] : value;
|
|
133
|
+
};
|
|
134
|
+
const parseSingularOf = (value, parse$6) => {
|
|
135
|
+
return parse$6(parseSingular(value));
|
|
136
|
+
};
|
|
137
|
+
const parseCsvOf = (value, parse$6) => {
|
|
138
|
+
if (!isNonEmptyStringOrNumber(value)) return;
|
|
139
|
+
const items = parseString(value)?.split(",");
|
|
140
|
+
if (items) return trimArray(items, parse$6);
|
|
141
|
+
};
|
|
142
|
+
const generateCsvOf = (value, generate$4) => {
|
|
143
|
+
if (!Array.isArray(value) || value.length === 0) return;
|
|
144
|
+
return trimArray(value, generate$4)?.join();
|
|
145
|
+
};
|
|
146
|
+
const generateXmlStylesheet = (stylesheet) => {
|
|
147
|
+
const generated = trimObject({
|
|
148
|
+
type: generatePlainString(stylesheet.type),
|
|
149
|
+
href: generatePlainString(stylesheet.href),
|
|
150
|
+
title: generatePlainString(stylesheet.title),
|
|
151
|
+
media: generatePlainString(stylesheet.media),
|
|
152
|
+
charset: generatePlainString(stylesheet.charset),
|
|
153
|
+
alternate: generateYesNoBoolean(stylesheet.alternate)
|
|
154
|
+
});
|
|
155
|
+
if (!generated) return;
|
|
156
|
+
let attributes = "";
|
|
157
|
+
for (const key in generated) {
|
|
158
|
+
const value = generated[key];
|
|
159
|
+
if (value !== void 0) attributes += ` ${key}="${value}"`;
|
|
160
|
+
}
|
|
161
|
+
return `<?xml-stylesheet${attributes}?>`;
|
|
162
|
+
};
|
|
163
|
+
const generateXml = (builder$3, value, options) => {
|
|
164
|
+
let body = builder$3.build(value);
|
|
165
|
+
if (body.includes("'")) body = body.replace(/'/g, "'");
|
|
166
|
+
let declaration = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
|
|
167
|
+
if (options?.stylesheets?.length) for (const stylesheetObject of options.stylesheets) {
|
|
168
|
+
const stylesheetString = generateXmlStylesheet(stylesheetObject);
|
|
169
|
+
if (stylesheetString) declaration += `\n${stylesheetString}`;
|
|
170
|
+
}
|
|
171
|
+
return `${declaration}\n${body}`;
|
|
172
|
+
};
|
|
173
|
+
const generateRfc822Date = (value) => {
|
|
174
|
+
if (!isPresent(value)) return;
|
|
175
|
+
const isString = typeof value === "string";
|
|
176
|
+
if (isString && !isNonEmptyString(value)) return;
|
|
177
|
+
const date = isString ? new Date(value) : value;
|
|
178
|
+
if (!Number.isNaN(date.getTime())) return date.toUTCString();
|
|
179
|
+
if (isString) return value;
|
|
180
|
+
};
|
|
181
|
+
const generateRfc3339Date = (value) => {
|
|
182
|
+
if (!isPresent(value)) return;
|
|
183
|
+
const isString = typeof value === "string";
|
|
184
|
+
if (isString && !isNonEmptyString(value)) return;
|
|
185
|
+
const date = isString ? new Date(value) : value;
|
|
186
|
+
if (!Number.isNaN(date.getTime())) return date.toISOString();
|
|
187
|
+
if (isString) return value;
|
|
188
|
+
};
|
|
189
|
+
const generateBoolean = (value) => {
|
|
190
|
+
if (typeof value === "boolean") return value;
|
|
191
|
+
};
|
|
192
|
+
const generateYesNoBoolean = (value) => {
|
|
193
|
+
if (typeof value !== "boolean") return;
|
|
194
|
+
return value ? "yes" : "no";
|
|
195
|
+
};
|
|
196
|
+
const detectNamespaces = (value, recursive = false) => {
|
|
197
|
+
const namespaces = /* @__PURE__ */ new Set();
|
|
198
|
+
const seenKeys = /* @__PURE__ */ new Set();
|
|
199
|
+
const traverse = (current) => {
|
|
200
|
+
if (Array.isArray(current)) {
|
|
201
|
+
for (const item of current) traverse(item);
|
|
202
|
+
return;
|
|
203
|
+
}
|
|
204
|
+
if (isObject(current)) for (const key in current) {
|
|
205
|
+
if (seenKeys.has(key)) continue;
|
|
206
|
+
seenKeys.add(key);
|
|
207
|
+
const keyWithoutAt = key.indexOf("@") === 0 ? key.slice(1) : key;
|
|
208
|
+
const colonIndex = keyWithoutAt.indexOf(":");
|
|
209
|
+
if (colonIndex > 0) namespaces.add(keyWithoutAt.slice(0, colonIndex));
|
|
210
|
+
if (recursive) traverse(current[key]);
|
|
211
|
+
}
|
|
212
|
+
};
|
|
213
|
+
traverse(value);
|
|
214
|
+
return namespaces;
|
|
215
|
+
};
|
|
216
|
+
const generateCdataString = (value) => {
|
|
217
|
+
if (!isNonEmptyString(value)) return;
|
|
218
|
+
if (value.indexOf("<") !== -1 || value.indexOf(">") !== -1 || value.indexOf("&") !== -1 || value.indexOf("]]>") !== -1) return { "#cdata": value.trim() };
|
|
219
|
+
return value.trim();
|
|
220
|
+
};
|
|
221
|
+
const generatePlainString = (value) => {
|
|
222
|
+
if (!isNonEmptyString(value)) return;
|
|
223
|
+
return value.trim();
|
|
224
|
+
};
|
|
225
|
+
const generateNumber = (value) => {
|
|
226
|
+
if (typeof value === "number" && Number.isFinite(value)) return value;
|
|
227
|
+
};
|
|
228
|
+
const generateNamespaceAttrs = (value, namespaceUrls$1) => {
|
|
229
|
+
if (!isObject(value)) return;
|
|
230
|
+
let namespaceAttrs;
|
|
231
|
+
const valueNamespaces = detectNamespaces(value, true);
|
|
232
|
+
for (const slug in namespaceUrls$1) {
|
|
233
|
+
if (!valueNamespaces.has(slug)) continue;
|
|
234
|
+
if (!namespaceAttrs) namespaceAttrs = {};
|
|
235
|
+
namespaceAttrs[`@xmlns:${slug}`] = namespaceUrls$1[slug];
|
|
236
|
+
}
|
|
237
|
+
return namespaceAttrs;
|
|
238
|
+
};
|
|
239
|
+
const invertObject = (object) => {
|
|
240
|
+
const inverted = {};
|
|
241
|
+
for (const key in object) inverted[object[key]] = key;
|
|
242
|
+
return inverted;
|
|
243
|
+
};
|
|
244
|
+
const createNamespaceNormalizator = (namespaceUrls$1, primaryNamespace) => {
|
|
245
|
+
const namespacesMap = invertObject(namespaceUrls$1);
|
|
246
|
+
const resolveNamespacePrefix = (uri, localName, fallback) => {
|
|
247
|
+
if (primaryNamespace && uri === primaryNamespace) return localName;
|
|
248
|
+
const standardPrefix = namespacesMap[uri];
|
|
249
|
+
if (standardPrefix) return `${standardPrefix}:${localName}`;
|
|
250
|
+
return fallback;
|
|
251
|
+
};
|
|
252
|
+
const extractNamespaceDeclarations = (element) => {
|
|
253
|
+
const declarations = {};
|
|
254
|
+
if (isObject(element)) {
|
|
255
|
+
for (const key in element) if (key === "@xmlns") declarations[""] = element[key];
|
|
256
|
+
else if (key.indexOf("@xmlns:") === 0) {
|
|
257
|
+
const prefix = key.substring(7);
|
|
258
|
+
declarations[prefix] = element[key];
|
|
259
|
+
}
|
|
260
|
+
}
|
|
261
|
+
return declarations;
|
|
262
|
+
};
|
|
263
|
+
const normalizeWithContext = (name, context, useDefault = false) => {
|
|
264
|
+
const colonIndex = name.indexOf(":");
|
|
265
|
+
if (colonIndex === -1) {
|
|
266
|
+
if (useDefault && context[""]) return resolveNamespacePrefix(context[""], name, name);
|
|
267
|
+
return name;
|
|
268
|
+
}
|
|
269
|
+
const prefix = name.substring(0, colonIndex);
|
|
270
|
+
const unprefixedName = name.substring(colonIndex + 1);
|
|
271
|
+
const uri = context[prefix];
|
|
272
|
+
if (uri) return resolveNamespacePrefix(uri, unprefixedName, name);
|
|
273
|
+
return name;
|
|
274
|
+
};
|
|
275
|
+
const normalizeKey = (key, context) => {
|
|
276
|
+
if (key.indexOf("@") === 0) {
|
|
277
|
+
const attrName = key.substring(1);
|
|
278
|
+
return `@${normalizeWithContext(attrName, context, false)}`;
|
|
279
|
+
} else return normalizeWithContext(key, context, true);
|
|
280
|
+
};
|
|
281
|
+
const traverseAndNormalize = (object, parentContext = {}) => {
|
|
282
|
+
if (!isObject(object)) return object;
|
|
283
|
+
if (Array.isArray(object)) return object.map((item) => traverseAndNormalize(item, parentContext));
|
|
284
|
+
const normalizedObject = {};
|
|
285
|
+
const keyGroups = /* @__PURE__ */ new Map();
|
|
286
|
+
const declarations = extractNamespaceDeclarations(object);
|
|
287
|
+
const currentContext = {
|
|
288
|
+
...parentContext,
|
|
289
|
+
...declarations
|
|
290
|
+
};
|
|
291
|
+
for (const key in object) {
|
|
292
|
+
const value = object[key];
|
|
293
|
+
if (key.indexOf("@xmlns") === 0) {
|
|
294
|
+
normalizedObject[key] = value;
|
|
295
|
+
continue;
|
|
296
|
+
}
|
|
297
|
+
const normalizedKey = normalizeKey(key, currentContext);
|
|
298
|
+
const normalizedValue = traverseAndNormalize(value, currentContext);
|
|
299
|
+
if (!keyGroups.has(normalizedKey)) keyGroups.set(normalizedKey, []);
|
|
300
|
+
const group = keyGroups.get(normalizedKey);
|
|
301
|
+
if (group) group.push(normalizedValue);
|
|
302
|
+
}
|
|
303
|
+
for (const [normalizedKey, values] of keyGroups) if (values.length === 1) normalizedObject[normalizedKey] = values[0];
|
|
304
|
+
else normalizedObject[normalizedKey] = values;
|
|
305
|
+
return normalizedObject;
|
|
306
|
+
};
|
|
307
|
+
const normalizeRoot = (object) => {
|
|
308
|
+
if (!isObject(object)) return object;
|
|
309
|
+
if (Array.isArray(object)) return object.map(normalizeRoot);
|
|
310
|
+
const normalizedObject = {};
|
|
311
|
+
for (const key in object) {
|
|
312
|
+
const value = object[key];
|
|
313
|
+
const declarations = extractNamespaceDeclarations(value);
|
|
314
|
+
const normalizedKey = Object.keys(declarations).length ? normalizeKey(key, declarations) : key;
|
|
315
|
+
normalizedObject[normalizedKey] = traverseAndNormalize(value);
|
|
316
|
+
}
|
|
317
|
+
return normalizedObject;
|
|
318
|
+
};
|
|
319
|
+
return normalizeRoot;
|
|
320
|
+
};
|
|
321
|
+
|
|
322
|
+
//#endregion
|
|
323
|
+
//#region src/feeds/atom/detect/index.ts
|
|
324
|
+
const detect = (value) => {
|
|
325
|
+
if (!isNonEmptyString(value)) return false;
|
|
326
|
+
if (!/(?:^|\s|>)\s*<(?:\w+:)?feed[\s>]/im.test(value)) return false;
|
|
327
|
+
const hasAtomNamespace = value.includes("http://www.w3.org/2005/Atom");
|
|
328
|
+
const hasAtomElements = /(<(?:\w+:)?(entry|title|link|id|updated|summary)[\s>])/i.test(value);
|
|
329
|
+
return hasAtomNamespace || hasAtomElements;
|
|
330
|
+
};
|
|
331
|
+
|
|
332
|
+
//#endregion
|
|
333
|
+
//#region src/common/config.ts
|
|
334
|
+
const parserConfig = {
|
|
335
|
+
trimValues: false,
|
|
336
|
+
processEntities: false,
|
|
337
|
+
htmlEntities: false,
|
|
338
|
+
parseTagValue: false,
|
|
339
|
+
parseAttributeValue: false,
|
|
340
|
+
alwaysCreateTextNode: false,
|
|
341
|
+
ignoreAttributes: false,
|
|
342
|
+
ignorePiTags: true,
|
|
343
|
+
ignoreDeclaration: true,
|
|
344
|
+
attributeNamePrefix: "@",
|
|
345
|
+
transformTagName: (name) => name.toLowerCase(),
|
|
346
|
+
transformAttributeName: (name) => name.toLowerCase()
|
|
347
|
+
};
|
|
348
|
+
const builderConfig = {
|
|
349
|
+
processEntities: true,
|
|
350
|
+
ignoreAttributes: false,
|
|
351
|
+
suppressEmptyNode: true,
|
|
352
|
+
suppressBooleanAttributes: false,
|
|
353
|
+
attributeNamePrefix: "@",
|
|
354
|
+
format: true,
|
|
355
|
+
cdataPropName: "#cdata"
|
|
356
|
+
};
|
|
357
|
+
const locales = {
|
|
358
|
+
unrecognized: "Unrecognized feed format",
|
|
359
|
+
invalid: "Invalid feed format"
|
|
360
|
+
};
|
|
361
|
+
const namespaceUrls = {
|
|
362
|
+
atom: "http://www.w3.org/2005/Atom",
|
|
363
|
+
dc: "http://purl.org/dc/elements/1.1/",
|
|
364
|
+
sy: "http://purl.org/rss/1.0/modules/syndication/",
|
|
365
|
+
content: "http://purl.org/rss/1.0/modules/content/",
|
|
366
|
+
slash: "http://purl.org/rss/1.0/modules/slash/",
|
|
367
|
+
itunes: "http://www.itunes.com/dtds/podcast-1.0.dtd",
|
|
368
|
+
podcast: "https://podcastindex.org/namespace/1.0",
|
|
369
|
+
psc: "http://podlove.org/simple-chapters",
|
|
370
|
+
media: "http://search.yahoo.com/mrss/",
|
|
371
|
+
georss: "http://www.georss.org/georss/",
|
|
372
|
+
thr: "http://purl.org/syndication/thread/1.0",
|
|
373
|
+
dcterms: "http://purl.org/dc/terms/",
|
|
374
|
+
wfw: "http://wellformedweb.org/CommentAPI/",
|
|
375
|
+
source: "http://source.scripting.com/",
|
|
376
|
+
yt: "http://www.youtube.com/xml/schemas/2015",
|
|
377
|
+
rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
|
378
|
+
};
|
|
379
|
+
|
|
380
|
+
//#endregion
|
|
381
|
+
//#region src/feeds/atom/parse/config.ts
|
|
382
|
+
const stopNodes$3 = [
|
|
383
|
+
"feed.author.name",
|
|
384
|
+
"feed.author.uri",
|
|
385
|
+
"feed.author.url",
|
|
386
|
+
"feed.author.email",
|
|
387
|
+
"feed.category",
|
|
388
|
+
"feed.contributor.name",
|
|
389
|
+
"feed.contributor.uri",
|
|
390
|
+
"feed.contributor.url",
|
|
391
|
+
"feed.contributor.email",
|
|
392
|
+
"feed.generator",
|
|
393
|
+
"feed.icon",
|
|
394
|
+
"feed.id",
|
|
395
|
+
"feed.link",
|
|
396
|
+
"feed.logo",
|
|
397
|
+
"feed.rights",
|
|
398
|
+
"feed.subtitle",
|
|
399
|
+
"feed.tagline",
|
|
400
|
+
"feed.title",
|
|
401
|
+
"feed.updated",
|
|
402
|
+
"feed.modified",
|
|
403
|
+
"feed.entry.author.name",
|
|
404
|
+
"feed.entry.author.uri",
|
|
405
|
+
"feed.entry.author.url",
|
|
406
|
+
"feed.entry.author.email",
|
|
407
|
+
"feed.entry.category",
|
|
408
|
+
"feed.entry.content",
|
|
409
|
+
"feed.entry.contributor.name",
|
|
410
|
+
"feed.entry.contributor.uri",
|
|
411
|
+
"feed.entry.contributor.url",
|
|
412
|
+
"feed.entry.contributor.email",
|
|
413
|
+
"feed.entry.id",
|
|
414
|
+
"feed.entry.link",
|
|
415
|
+
"feed.entry.published",
|
|
416
|
+
"feed.entry.issued",
|
|
417
|
+
"feed.entry.created",
|
|
418
|
+
"feed.entry.rights",
|
|
419
|
+
"feed.entry.source.author.name",
|
|
420
|
+
"feed.entry.source.author.uri",
|
|
421
|
+
"feed.entry.source.author.url",
|
|
422
|
+
"feed.entry.source.author.email",
|
|
423
|
+
"feed.entry.source.category",
|
|
424
|
+
"feed.entry.source.contributor.name",
|
|
425
|
+
"feed.entry.source.contributor.uri",
|
|
426
|
+
"feed.entry.source.contributor.url",
|
|
427
|
+
"feed.entry.source.contributor.email",
|
|
428
|
+
"feed.entry.source.generator",
|
|
429
|
+
"feed.entry.source.icon",
|
|
430
|
+
"feed.entry.source.id",
|
|
431
|
+
"feed.entry.source.link",
|
|
432
|
+
"feed.entry.source.logo",
|
|
433
|
+
"feed.entry.source.rights",
|
|
434
|
+
"feed.entry.source.subtitle",
|
|
435
|
+
"feed.entry.source.title,",
|
|
436
|
+
"feed.entry.source.updated",
|
|
437
|
+
"feed.entry.source.modified",
|
|
438
|
+
"feed.entry.summary",
|
|
439
|
+
"feed.entry.title",
|
|
440
|
+
"feed.entry.updated",
|
|
441
|
+
"feed.entry.modified"
|
|
442
|
+
];
|
|
443
|
+
const parser$3 = new XMLParser({
|
|
444
|
+
...parserConfig,
|
|
445
|
+
stopNodes: stopNodes$3
|
|
446
|
+
});
|
|
447
|
+
|
|
448
|
+
//#endregion
|
|
449
|
+
//#region src/namespaces/dc/parse/utils.ts
|
|
450
|
+
const retrieveItemOrFeed = (value) => {
|
|
451
|
+
if (!isObject(value)) return;
|
|
452
|
+
const itemOrFeed = {
|
|
453
|
+
title: parseSingularOf(value["dc:title"], (value$1) => parseString(retrieveText(value$1))),
|
|
454
|
+
creator: parseSingularOf(value["dc:creator"], (value$1) => parseString(retrieveText(value$1))),
|
|
455
|
+
subject: parseSingularOf(value["dc:subject"], (value$1) => parseString(retrieveText(value$1))),
|
|
456
|
+
description: parseSingularOf(value["dc:description"], (value$1) => parseString(retrieveText(value$1))),
|
|
457
|
+
publisher: parseSingularOf(value["dc:publisher"], (value$1) => parseString(retrieveText(value$1))),
|
|
458
|
+
contributor: parseSingularOf(value["dc:contributor"], (value$1) => parseString(retrieveText(value$1))),
|
|
459
|
+
date: parseSingularOf(value["dc:date"], (value$1) => parseDate(retrieveText(value$1))),
|
|
460
|
+
type: parseSingularOf(value["dc:type"], (value$1) => parseString(retrieveText(value$1))),
|
|
461
|
+
format: parseSingularOf(value["dc:format"], (value$1) => parseString(retrieveText(value$1))),
|
|
462
|
+
identifier: parseSingularOf(value["dc:identifier"], (value$1) => parseString(retrieveText(value$1))),
|
|
463
|
+
source: parseSingularOf(value["dc:source"], (value$1) => parseString(retrieveText(value$1))),
|
|
464
|
+
language: parseSingularOf(value["dc:language"], (value$1) => parseString(retrieveText(value$1))),
|
|
465
|
+
relation: parseSingularOf(value["dc:relation"], (value$1) => parseString(retrieveText(value$1))),
|
|
466
|
+
coverage: parseSingularOf(value["dc:coverage"], (value$1) => parseString(retrieveText(value$1))),
|
|
467
|
+
rights: parseSingularOf(value["dc:rights"], (value$1) => parseString(retrieveText(value$1)))
|
|
468
|
+
};
|
|
469
|
+
return trimObject(itemOrFeed);
|
|
470
|
+
};
|
|
471
|
+
|
|
472
|
+
//#endregion
|
|
473
|
+
//#region src/namespaces/dcterms/parse/utils.ts
|
|
474
|
+
const retrieveItemOrFeed$1 = (value) => {
|
|
475
|
+
if (!isObject(value)) return;
|
|
476
|
+
const itemOrFeed = {
|
|
477
|
+
abstract: parseSingularOf(value["dcterms:abstract"], (value$1) => parseString(retrieveText(value$1))),
|
|
478
|
+
accessRights: parseSingularOf(value["dcterms:accessrights"], (value$1) => parseString(retrieveText(value$1))),
|
|
479
|
+
accrualMethod: parseSingularOf(value["dcterms:accrualmethod"], (value$1) => parseString(retrieveText(value$1))),
|
|
480
|
+
accrualPeriodicity: parseSingularOf(value["dcterms:accrualperiodicity"], (value$1) => parseString(retrieveText(value$1))),
|
|
481
|
+
accrualPolicy: parseSingularOf(value["dcterms:accrualpolicy"], (value$1) => parseString(retrieveText(value$1))),
|
|
482
|
+
alternative: parseSingularOf(value["dcterms:alternative"], (value$1) => parseString(retrieveText(value$1))),
|
|
483
|
+
audience: parseSingularOf(value["dcterms:audience"], (value$1) => parseString(retrieveText(value$1))),
|
|
484
|
+
available: parseSingularOf(value["dcterms:available"], (value$1) => parseDate(retrieveText(value$1))),
|
|
485
|
+
bibliographicCitation: parseSingularOf(value["dcterms:bibliographiccitation"], (value$1) => parseString(retrieveText(value$1))),
|
|
486
|
+
conformsTo: parseSingularOf(value["dcterms:conformsto"], (value$1) => parseString(retrieveText(value$1))),
|
|
487
|
+
contributor: parseSingularOf(value["dcterms:contributor"], (value$1) => parseString(retrieveText(value$1))),
|
|
488
|
+
coverage: parseSingularOf(value["dcterms:coverage"], (value$1) => parseString(retrieveText(value$1))),
|
|
489
|
+
created: parseSingularOf(value["dcterms:created"], (value$1) => parseDate(retrieveText(value$1))),
|
|
490
|
+
creator: parseSingularOf(value["dcterms:creator"], (value$1) => parseString(retrieveText(value$1))),
|
|
491
|
+
date: parseSingularOf(value["dcterms:date"], (value$1) => parseDate(retrieveText(value$1))),
|
|
492
|
+
dateAccepted: parseSingularOf(value["dcterms:dateaccepted"], (value$1) => parseDate(retrieveText(value$1))),
|
|
493
|
+
dateCopyrighted: parseSingularOf(value["dcterms:datecopyrighted"], (value$1) => parseDate(retrieveText(value$1))),
|
|
494
|
+
dateSubmitted: parseSingularOf(value["dcterms:datesubmitted"], (value$1) => parseDate(retrieveText(value$1))),
|
|
495
|
+
description: parseSingularOf(value["dcterms:description"], (value$1) => parseString(retrieveText(value$1))),
|
|
496
|
+
educationLevel: parseSingularOf(value["dcterms:educationlevel"], (value$1) => parseString(retrieveText(value$1))),
|
|
497
|
+
extent: parseSingularOf(value["dcterms:extent"], (value$1) => parseString(retrieveText(value$1))),
|
|
498
|
+
format: parseSingularOf(value["dcterms:format"], (value$1) => parseString(retrieveText(value$1))),
|
|
499
|
+
hasFormat: parseSingularOf(value["dcterms:hasformat"], (value$1) => parseString(retrieveText(value$1))),
|
|
500
|
+
hasPart: parseSingularOf(value["dcterms:haspart"], (value$1) => parseString(retrieveText(value$1))),
|
|
501
|
+
hasVersion: parseSingularOf(value["dcterms:hasversion"], (value$1) => parseString(retrieveText(value$1))),
|
|
502
|
+
identifier: parseSingularOf(value["dcterms:identifier"], (value$1) => parseString(retrieveText(value$1))),
|
|
503
|
+
instructionalMethod: parseSingularOf(value["dcterms:instructionalmethod"], (value$1) => parseString(retrieveText(value$1))),
|
|
504
|
+
isFormatOf: parseSingularOf(value["dcterms:isformatof"], (value$1) => parseString(retrieveText(value$1))),
|
|
505
|
+
isPartOf: parseSingularOf(value["dcterms:ispartof"], (value$1) => parseString(retrieveText(value$1))),
|
|
506
|
+
isReferencedBy: parseSingularOf(value["dcterms:isreferencedby"], (value$1) => parseString(retrieveText(value$1))),
|
|
507
|
+
isReplacedBy: parseSingularOf(value["dcterms:isreplacedby"], (value$1) => parseString(retrieveText(value$1))),
|
|
508
|
+
isRequiredBy: parseSingularOf(value["dcterms:isrequiredby"], (value$1) => parseString(retrieveText(value$1))),
|
|
509
|
+
issued: parseSingularOf(value["dcterms:issued"], (value$1) => parseDate(retrieveText(value$1))),
|
|
510
|
+
isVersionOf: parseSingularOf(value["dcterms:isversionof"], (value$1) => parseString(retrieveText(value$1))),
|
|
511
|
+
language: parseSingularOf(value["dcterms:language"], (value$1) => parseString(retrieveText(value$1))),
|
|
512
|
+
license: parseSingularOf(value["dcterms:license"], (value$1) => parseString(retrieveText(value$1))),
|
|
513
|
+
mediator: parseSingularOf(value["dcterms:mediator"], (value$1) => parseString(retrieveText(value$1))),
|
|
514
|
+
medium: parseSingularOf(value["dcterms:medium"], (value$1) => parseString(retrieveText(value$1))),
|
|
515
|
+
modified: parseSingularOf(value["dcterms:modified"], (value$1) => parseDate(retrieveText(value$1))),
|
|
516
|
+
provenance: parseSingularOf(value["dcterms:provenance"], (value$1) => parseString(retrieveText(value$1))),
|
|
517
|
+
publisher: parseSingularOf(value["dcterms:publisher"], (value$1) => parseString(retrieveText(value$1))),
|
|
518
|
+
references: parseSingularOf(value["dcterms:references"], (value$1) => parseString(retrieveText(value$1))),
|
|
519
|
+
relation: parseSingularOf(value["dcterms:relation"], (value$1) => parseString(retrieveText(value$1))),
|
|
520
|
+
replaces: parseSingularOf(value["dcterms:replaces"], (value$1) => parseString(retrieveText(value$1))),
|
|
521
|
+
requires: parseSingularOf(value["dcterms:requires"], (value$1) => parseString(retrieveText(value$1))),
|
|
522
|
+
rights: parseSingularOf(value["dcterms:rights"], (value$1) => parseString(retrieveText(value$1))),
|
|
523
|
+
rightsHolder: parseSingularOf(value["dcterms:rightsholder"], (value$1) => parseString(retrieveText(value$1))),
|
|
524
|
+
source: parseSingularOf(value["dcterms:source"], (value$1) => parseString(retrieveText(value$1))),
|
|
525
|
+
spatial: parseSingularOf(value["dcterms:spatial"], (value$1) => parseString(retrieveText(value$1))),
|
|
526
|
+
subject: parseSingularOf(value["dcterms:subject"], (value$1) => parseString(retrieveText(value$1))),
|
|
527
|
+
tableOfContents: parseSingularOf(value["dcterms:tableofcontents"], (value$1) => parseString(retrieveText(value$1))),
|
|
528
|
+
temporal: parseSingularOf(value["dcterms:temporal"], (value$1) => parseString(retrieveText(value$1))),
|
|
529
|
+
title: parseSingularOf(value["dcterms:title"], (value$1) => parseString(retrieveText(value$1))),
|
|
530
|
+
type: parseSingularOf(value["dcterms:type"], (value$1) => parseString(retrieveText(value$1))),
|
|
531
|
+
valid: parseSingularOf(value["dcterms:valid"], (value$1) => parseDate(retrieveText(value$1)))
|
|
532
|
+
};
|
|
533
|
+
return trimObject(itemOrFeed);
|
|
534
|
+
};
|
|
535
|
+
|
|
536
|
+
//#endregion
|
|
537
|
+
//#region src/namespaces/georss/parse/utils.ts
|
|
538
|
+
const parseLatLngPairs = (value, pairsCount) => {
|
|
539
|
+
if (!isNonEmptyString(value)) return;
|
|
540
|
+
const rawParts = value.split(/\s+/);
|
|
541
|
+
const numericParts = parseArrayOf(rawParts, parseNumber);
|
|
542
|
+
if (!numericParts || numericParts.length % 2 !== 0 || rawParts.length !== numericParts.length) return;
|
|
543
|
+
const actualPairCount = numericParts.length / 2;
|
|
544
|
+
if (pairsCount?.min && actualPairCount < pairsCount?.min || pairsCount?.max && actualPairCount > pairsCount?.max) return;
|
|
545
|
+
const points = [];
|
|
546
|
+
for (let i = 0; i < numericParts.length; i += 2) {
|
|
547
|
+
const lat = numericParts[i];
|
|
548
|
+
const lng = numericParts[i + 1];
|
|
549
|
+
if (isPresent(lat) && isPresent(lng)) points.push({
|
|
550
|
+
lat,
|
|
551
|
+
lng
|
|
552
|
+
});
|
|
553
|
+
}
|
|
554
|
+
return points.length > 0 ? points : void 0;
|
|
555
|
+
};
|
|
556
|
+
const parsePoint = (value) => {
|
|
557
|
+
return parseLatLngPairs(retrieveText(value), {
|
|
558
|
+
min: 1,
|
|
559
|
+
max: 1
|
|
560
|
+
})?.[0];
|
|
561
|
+
};
|
|
562
|
+
const parseLine = (value) => {
|
|
563
|
+
const points = parseLatLngPairs(retrieveText(value), { min: 2 });
|
|
564
|
+
if (isPresent(points)) return { points };
|
|
565
|
+
};
|
|
566
|
+
const parsePolygon = (value) => {
|
|
567
|
+
const points = parseLatLngPairs(retrieveText(value), { min: 4 });
|
|
568
|
+
if (isPresent(points)) return { points };
|
|
569
|
+
};
|
|
570
|
+
const parseBox = (value) => {
|
|
571
|
+
const points = parseLatLngPairs(retrieveText(value), {
|
|
572
|
+
min: 2,
|
|
573
|
+
max: 2
|
|
574
|
+
});
|
|
575
|
+
const lowerCorner = points?.[0];
|
|
576
|
+
const upperCorner = points?.[1];
|
|
577
|
+
if (isPresent(lowerCorner) && isPresent(upperCorner)) return {
|
|
578
|
+
lowerCorner,
|
|
579
|
+
upperCorner
|
|
580
|
+
};
|
|
581
|
+
};
|
|
582
|
+
const retrieveItemOrFeed$2 = (value) => {
|
|
583
|
+
if (!isObject(value)) return;
|
|
584
|
+
const itemOrFeed = {
|
|
585
|
+
point: parseSingularOf(value["georss:point"], parsePoint),
|
|
586
|
+
line: parseSingularOf(value["georss:line"], parseLine),
|
|
587
|
+
polygon: parseSingularOf(value["georss:polygon"], parsePolygon),
|
|
588
|
+
box: parseSingularOf(value["georss:box"], parseBox),
|
|
589
|
+
featureTypeTag: parseSingularOf(value["georss:featuretypetag"], (value$1) => parseString(retrieveText(value$1))),
|
|
590
|
+
relationshipTag: parseSingularOf(value["georss:relationshiptag"], (value$1) => parseString(retrieveText(value$1))),
|
|
591
|
+
featureName: parseSingularOf(value["georss:featurename"], (value$1) => parseString(retrieveText(value$1))),
|
|
592
|
+
elev: parseSingularOf(value["georss:elev"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
593
|
+
floor: parseSingularOf(value["georss:floor"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
594
|
+
radius: parseSingularOf(value["georss:radius"], (value$1) => parseNumber(retrieveText(value$1)))
|
|
595
|
+
};
|
|
596
|
+
return trimObject(itemOrFeed);
|
|
597
|
+
};
|
|
598
|
+
|
|
599
|
+
//#endregion
|
|
600
|
+
//#region src/namespaces/itunes/parse/utils.ts
|
|
601
|
+
const parseCategory$3 = (value) => {
|
|
602
|
+
if (!isObject(value)) return;
|
|
603
|
+
const category = {
|
|
604
|
+
text: parseString(value["@text"]),
|
|
605
|
+
categories: parseArrayOf(value["itunes:category"], parseCategory$3)
|
|
606
|
+
};
|
|
607
|
+
return trimObject(category);
|
|
608
|
+
};
|
|
609
|
+
const parseOwner = (value) => {
|
|
610
|
+
if (!isObject(value)) return;
|
|
611
|
+
const owner = {
|
|
612
|
+
name: parseSingularOf(value["itunes:name"], (value$1) => parseString(retrieveText(value$1))),
|
|
613
|
+
email: parseSingularOf(value["itunes:email"], (value$1) => parseString(retrieveText(value$1)))
|
|
614
|
+
};
|
|
615
|
+
return trimObject(owner);
|
|
616
|
+
};
|
|
617
|
+
const explicitOrYesRegex = /^\p{White_Space}*(explicit|yes)\p{White_Space}*$/iu;
|
|
618
|
+
const parseExplicit = (value) => {
|
|
619
|
+
const boolean = parseBoolean(value);
|
|
620
|
+
if (boolean !== void 0) return boolean;
|
|
621
|
+
if (typeof value === "string") return explicitOrYesRegex.test(value);
|
|
622
|
+
};
|
|
623
|
+
const parseDuration = (value) => {
|
|
624
|
+
const duration = parseNumber(value);
|
|
625
|
+
if (duration !== void 0) return duration;
|
|
626
|
+
if (typeof value !== "string") return;
|
|
627
|
+
const match = value.match(/^(?:(\d+):)?(\d+):(\d+)$/);
|
|
628
|
+
if (match) {
|
|
629
|
+
const [, hours, minutes, seconds] = match;
|
|
630
|
+
return Number(hours || 0) * 3600 + Number(minutes) * 60 + Number(seconds);
|
|
631
|
+
}
|
|
632
|
+
};
|
|
633
|
+
const parseImage$2 = (value) => {
|
|
634
|
+
if (isNonEmptyStringOrNumber(value)) return parseString(value);
|
|
635
|
+
if (!isObject(value)) return;
|
|
636
|
+
return parseString(value["@href"]);
|
|
637
|
+
};
|
|
638
|
+
const retrieveItem$1 = (value) => {
|
|
639
|
+
if (!isObject(value)) return;
|
|
640
|
+
const item = {
|
|
641
|
+
duration: parseSingularOf(value["itunes:duration"], (value$1) => parseDuration(retrieveText(value$1))),
|
|
642
|
+
image: parseSingularOf(value["itunes:image"], parseImage$2),
|
|
643
|
+
explicit: parseSingularOf(value["itunes:explicit"], (value$1) => parseExplicit(retrieveText(value$1))),
|
|
644
|
+
title: parseSingularOf(value["itunes:title"], (value$1) => parseString(retrieveText(value$1))),
|
|
645
|
+
episode: parseSingularOf(value["itunes:episode"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
646
|
+
season: parseSingularOf(value["itunes:season"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
647
|
+
episodeType: parseSingularOf(value["itunes:episodetype"], (value$1) => parseString(retrieveText(value$1))),
|
|
648
|
+
block: parseSingularOf(value["itunes:block"], (value$1) => parseYesNoBoolean(retrieveText(value$1))),
|
|
649
|
+
summary: parseSingularOf(value["itunes:summary"], (value$1) => parseString(retrieveText(value$1))),
|
|
650
|
+
subtitle: parseSingularOf(value["itunes:subtitle"], (value$1) => parseString(retrieveText(value$1))),
|
|
651
|
+
keywords: parseSingularOf(value["itunes:keywords"], (value$1) => parseCsvOf(retrieveText(value$1), parseString))
|
|
652
|
+
};
|
|
653
|
+
return trimObject(item);
|
|
654
|
+
};
|
|
655
|
+
const retrieveFeed$2 = (value) => {
|
|
656
|
+
if (!isObject(value)) return;
|
|
657
|
+
const feed = {
|
|
658
|
+
image: parseSingularOf(value["itunes:image"], parseImage$2),
|
|
659
|
+
explicit: parseSingularOf(value["itunes:explicit"], (value$1) => parseExplicit(retrieveText(value$1))),
|
|
660
|
+
author: parseSingularOf(value["itunes:author"], (value$1) => parseString(retrieveText(value$1))),
|
|
661
|
+
title: parseSingularOf(value["itunes:title"], (value$1) => parseString(retrieveText(value$1))),
|
|
662
|
+
type: parseSingularOf(value["itunes:type"], (value$1) => parseString(retrieveText(value$1))),
|
|
663
|
+
newFeedUrl: parseSingularOf(value["itunes:new-feed-url"], (value$1) => parseString(retrieveText(value$1))),
|
|
664
|
+
block: parseSingularOf(value["itunes:block"], (value$1) => parseYesNoBoolean(retrieveText(value$1))),
|
|
665
|
+
complete: parseSingularOf(value["itunes:complete"], (value$1) => parseYesNoBoolean(retrieveText(value$1))),
|
|
666
|
+
applePodcastsVerify: parseSingularOf(value["itunes:applepodcastsverify"], (value$1) => parseString(retrieveText(value$1))),
|
|
667
|
+
categories: parseArrayOf(value["itunes:category"], parseCategory$3),
|
|
668
|
+
owner: parseSingularOf(value["itunes:owner"], parseOwner),
|
|
669
|
+
summary: parseSingularOf(value["itunes:summary"], (value$1) => parseString(retrieveText(value$1))),
|
|
670
|
+
subtitle: parseSingularOf(value["itunes:subtitle"], (value$1) => parseString(retrieveText(value$1))),
|
|
671
|
+
keywords: parseSingularOf(value["itunes:keywords"], (value$1) => parseCsvOf(retrieveText(value$1), parseString))
|
|
672
|
+
};
|
|
673
|
+
return trimObject(feed);
|
|
674
|
+
};
|
|
675
|
+
|
|
676
|
+
//#endregion
|
|
677
|
+
//#region src/namespaces/media/parse/utils.ts
|
|
678
|
+
const parseRating = (value) => {
|
|
679
|
+
const rating = {
|
|
680
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
681
|
+
scheme: parseString(value?.["@scheme"])
|
|
682
|
+
};
|
|
683
|
+
return trimObject(rating);
|
|
684
|
+
};
|
|
685
|
+
const retrieveRatings = (value) => {
|
|
686
|
+
if (!isObject(value)) return;
|
|
687
|
+
if (value["media:rating"]) return parseArrayOf(value["media:rating"], parseRating);
|
|
688
|
+
if (value["media:adult"]) return [{
|
|
689
|
+
value: parseBoolean(retrieveText(value["media:adult"])) ? "adult" : "nonadult",
|
|
690
|
+
scheme: "urn:simple"
|
|
691
|
+
}];
|
|
692
|
+
};
|
|
693
|
+
const parseTitleOrDescription = (value) => {
|
|
694
|
+
const title = {
|
|
695
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
696
|
+
type: parseString(value?.["@type"])
|
|
697
|
+
};
|
|
698
|
+
return trimObject(title);
|
|
699
|
+
};
|
|
700
|
+
const parseThumbnail = (value) => {
|
|
701
|
+
if (!isObject(value)) return;
|
|
702
|
+
const thumbnail = {
|
|
703
|
+
url: parseString(value["@url"]),
|
|
704
|
+
height: parseNumber(value["@height"]),
|
|
705
|
+
width: parseNumber(value["@width"]),
|
|
706
|
+
time: parseString(value["@time"])
|
|
707
|
+
};
|
|
708
|
+
return trimObject(thumbnail);
|
|
709
|
+
};
|
|
710
|
+
const parseCategory$2 = (value) => {
|
|
711
|
+
const category = {
|
|
712
|
+
name: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
713
|
+
scheme: parseString(value?.["@scheme"]),
|
|
714
|
+
label: parseString(value?.["@label"])
|
|
715
|
+
};
|
|
716
|
+
return trimObject(category);
|
|
717
|
+
};
|
|
718
|
+
const parseHash = (value) => {
|
|
719
|
+
const hash = {
|
|
720
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
721
|
+
algo: parseString(value?.["@algo"])
|
|
722
|
+
};
|
|
723
|
+
return trimObject(hash);
|
|
724
|
+
};
|
|
725
|
+
const parsePlayer = (value) => {
|
|
726
|
+
if (!isObject(value)) return;
|
|
727
|
+
const player = {
|
|
728
|
+
url: parseString(value["@url"]),
|
|
729
|
+
height: parseNumber(value["@height"]),
|
|
730
|
+
width: parseNumber(value["@width"])
|
|
731
|
+
};
|
|
732
|
+
return trimObject(player);
|
|
733
|
+
};
|
|
734
|
+
const parseCredit = (value) => {
|
|
735
|
+
const credit = {
|
|
736
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
737
|
+
role: parseString(value?.["@role"]),
|
|
738
|
+
scheme: parseString(value?.["@scheme"])
|
|
739
|
+
};
|
|
740
|
+
return trimObject(credit);
|
|
741
|
+
};
|
|
742
|
+
const parseCopyright = (value) => {
|
|
743
|
+
const copyright = {
|
|
744
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
745
|
+
url: parseString(value?.["@url"])
|
|
746
|
+
};
|
|
747
|
+
return trimObject(copyright);
|
|
748
|
+
};
|
|
749
|
+
const parseText = (value) => {
|
|
750
|
+
const text = {
|
|
751
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
752
|
+
type: parseString(value?.["@type"]),
|
|
753
|
+
lang: parseString(value?.["@lang"]),
|
|
754
|
+
start: parseString(value?.["@start"]),
|
|
755
|
+
end: parseString(value?.["@end"])
|
|
756
|
+
};
|
|
757
|
+
return trimObject(text);
|
|
758
|
+
};
|
|
759
|
+
const parseRestriction = (value) => {
|
|
760
|
+
if (!isObject(value)) return;
|
|
761
|
+
const restriction = {
|
|
762
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
763
|
+
relationship: parseString(value["@relationship"]),
|
|
764
|
+
type: parseString(value["@type"])
|
|
765
|
+
};
|
|
766
|
+
return trimObject(restriction);
|
|
767
|
+
};
|
|
768
|
+
const parseCommunity = (value) => {
|
|
769
|
+
if (!isObject(value)) return;
|
|
770
|
+
const community = {
|
|
771
|
+
starRating: parseSingularOf(value["media:starrating"], parseStarRating),
|
|
772
|
+
statistics: parseSingularOf(value["media:statistics"], parseStatistics),
|
|
773
|
+
tags: parseSingularOf(value["media:tags"], parseTags)
|
|
774
|
+
};
|
|
775
|
+
return trimObject(community);
|
|
776
|
+
};
|
|
777
|
+
const parseStarRating = (value) => {
|
|
778
|
+
if (!isObject(value)) return;
|
|
779
|
+
const starRating = {
|
|
780
|
+
average: parseNumber(value["@average"]),
|
|
781
|
+
count: parseNumber(value["@count"]),
|
|
782
|
+
min: parseNumber(value["@min"]),
|
|
783
|
+
max: parseNumber(value["@max"])
|
|
784
|
+
};
|
|
785
|
+
return trimObject(starRating);
|
|
786
|
+
};
|
|
787
|
+
const parseStatistics = (value) => {
|
|
788
|
+
if (!isObject(value)) return;
|
|
789
|
+
const statistics = {
|
|
790
|
+
views: parseNumber(value["@views"]),
|
|
791
|
+
favorites: parseNumber(value["@favorites"])
|
|
792
|
+
};
|
|
793
|
+
return trimObject(statistics);
|
|
794
|
+
};
|
|
795
|
+
const parseTags = (value) => {
|
|
796
|
+
return parseCsvOf(value, (segment) => {
|
|
797
|
+
const split = segment.split(":");
|
|
798
|
+
return {
|
|
799
|
+
name: parseString(split[0]) ?? "",
|
|
800
|
+
weight: parseNumber(split[1]) ?? 1
|
|
801
|
+
};
|
|
802
|
+
});
|
|
803
|
+
};
|
|
804
|
+
const parseComments = (value) => {
|
|
805
|
+
return parseArrayOf(value?.["media:comment"], (value$1) => parseString(retrieveText(value$1)));
|
|
806
|
+
};
|
|
807
|
+
const parseEmbed = (value) => {
|
|
808
|
+
if (!isObject(value)) return;
|
|
809
|
+
const embed = {
|
|
810
|
+
url: parseString(value["@url"]),
|
|
811
|
+
width: parseNumber(value["@width"]),
|
|
812
|
+
height: parseNumber(value["@height"]),
|
|
813
|
+
params: parseArrayOf(value["media:param"], parseParam)
|
|
814
|
+
};
|
|
815
|
+
return trimObject(embed);
|
|
816
|
+
};
|
|
817
|
+
const parseParam = (value) => {
|
|
818
|
+
if (!isObject(value)) return;
|
|
819
|
+
const param = {
|
|
820
|
+
name: parseString(value["@name"]),
|
|
821
|
+
value: ((value$1) => parseString(retrieveText(value$1)))(value)
|
|
822
|
+
};
|
|
823
|
+
return trimObject(param);
|
|
824
|
+
};
|
|
825
|
+
const parseResponses = (value) => {
|
|
826
|
+
return parseArrayOf(value?.["media:response"], (value$1) => parseString(retrieveText(value$1)));
|
|
827
|
+
};
|
|
828
|
+
const parseBackLinks = (value) => {
|
|
829
|
+
return parseArrayOf(value?.["media:backlink"], (value$1) => parseString(retrieveText(value$1)));
|
|
830
|
+
};
|
|
831
|
+
const parseStatus = (value) => {
|
|
832
|
+
if (!isObject(value)) return;
|
|
833
|
+
const status = {
|
|
834
|
+
state: parseString(value["@state"]),
|
|
835
|
+
reason: parseString(value["@reason"])
|
|
836
|
+
};
|
|
837
|
+
return trimObject(status);
|
|
838
|
+
};
|
|
839
|
+
const parsePrice = (value) => {
|
|
840
|
+
if (!isObject(value)) return;
|
|
841
|
+
const price = {
|
|
842
|
+
type: parseString(value["@type"]),
|
|
843
|
+
info: parseString(value["@info"]),
|
|
844
|
+
price: parseNumber(value["@price"]),
|
|
845
|
+
currency: parseString(value["@currency"])
|
|
846
|
+
};
|
|
847
|
+
return trimObject(price);
|
|
848
|
+
};
|
|
849
|
+
const parseLicense$1 = (value) => {
|
|
850
|
+
const license = {
|
|
851
|
+
name: ((value$1) => parseString(retrieveText(value$1)))(value),
|
|
852
|
+
type: parseString(value?.["@type"]),
|
|
853
|
+
href: parseString(value?.["@href"])
|
|
854
|
+
};
|
|
855
|
+
return trimObject(license);
|
|
856
|
+
};
|
|
857
|
+
const parseSubTitle = (value) => {
|
|
858
|
+
if (!isObject(value)) return;
|
|
859
|
+
const subTitle = {
|
|
860
|
+
type: parseString(value["@type"]),
|
|
861
|
+
lang: parseString(value["@lang"]),
|
|
862
|
+
href: parseString(value["@href"])
|
|
863
|
+
};
|
|
864
|
+
return trimObject(subTitle);
|
|
865
|
+
};
|
|
866
|
+
const parsePeerLink = (value) => {
|
|
867
|
+
if (!isObject(value)) return;
|
|
868
|
+
const peerLink = {
|
|
869
|
+
type: parseString(value["@type"]),
|
|
870
|
+
href: parseString(value["@href"])
|
|
871
|
+
};
|
|
872
|
+
return trimObject(peerLink);
|
|
873
|
+
};
|
|
874
|
+
const parseRights = (value) => {
|
|
875
|
+
if (!isObject(value)) return;
|
|
876
|
+
const rights = { status: parseString(value["@status"]) };
|
|
877
|
+
return trimObject(rights);
|
|
878
|
+
};
|
|
879
|
+
const parseScene = (value) => {
|
|
880
|
+
if (!isObject(value)) return;
|
|
881
|
+
const scene = {
|
|
882
|
+
title: parseSingularOf(value.scenetitle, (value$1) => parseString(retrieveText(value$1))),
|
|
883
|
+
description: parseSingularOf(value.scenedescription, (value$1) => parseString(retrieveText(value$1))),
|
|
884
|
+
startTime: parseSingularOf(value.scenestarttime, (value$1) => parseString(retrieveText(value$1))),
|
|
885
|
+
endTime: parseSingularOf(value.sceneendtime, (value$1) => parseString(retrieveText(value$1)))
|
|
886
|
+
};
|
|
887
|
+
return trimObject(scene);
|
|
888
|
+
};
|
|
889
|
+
const parseScenes = (value) => {
|
|
890
|
+
return parseArrayOf(value?.["media:scene"], parseScene);
|
|
891
|
+
};
|
|
892
|
+
const parseLocation$1 = (value) => {
|
|
893
|
+
if (isNonEmptyStringOrNumber(value) || isObject(value)) {
|
|
894
|
+
const location = { description: ((value$1) => parseString(retrieveText(value$1)))(value) };
|
|
895
|
+
return trimObject(location);
|
|
896
|
+
}
|
|
897
|
+
};
|
|
898
|
+
const retrieveCommonElements = (value) => {
|
|
899
|
+
if (!isObject(value)) return;
|
|
900
|
+
const commonElements = {
|
|
901
|
+
ratings: retrieveRatings(value),
|
|
902
|
+
title: parseSingularOf(value["media:title"], parseTitleOrDescription),
|
|
903
|
+
description: parseSingularOf(value["media:description"], parseTitleOrDescription),
|
|
904
|
+
keywords: parseSingularOf(value["media:keywords"], (value$1) => parseCsvOf(retrieveText(value$1), parseString)),
|
|
905
|
+
thumbnails: parseArrayOf(value["media:thumbnail"], parseThumbnail),
|
|
906
|
+
categories: parseArrayOf(value["media:category"], parseCategory$2),
|
|
907
|
+
hashes: parseArrayOf(value["media:hash"], parseHash),
|
|
908
|
+
player: parseSingularOf(value["media:player"], parsePlayer),
|
|
909
|
+
credits: parseArrayOf(value["media:credit"], parseCredit),
|
|
910
|
+
copyright: parseSingularOf(value["media:copyright"], parseCopyright),
|
|
911
|
+
texts: parseArrayOf(value["media:text"], parseText),
|
|
912
|
+
restrictions: parseArrayOf(value["media:restriction"], parseRestriction),
|
|
913
|
+
community: parseSingularOf(value["media:community"], parseCommunity),
|
|
914
|
+
comments: parseSingularOf(value["media:comments"], parseComments),
|
|
915
|
+
embed: parseSingularOf(value["media:embed"], parseEmbed),
|
|
916
|
+
responses: parseSingularOf(value["media:responses"], parseResponses),
|
|
917
|
+
backLinks: parseSingularOf(value["media:backlinks"], parseBackLinks),
|
|
918
|
+
status: parseSingularOf(value["media:status"], parseStatus),
|
|
919
|
+
prices: parseArrayOf(value["media:price"], parsePrice),
|
|
920
|
+
licenses: parseArrayOf(value["media:license"], parseLicense$1),
|
|
921
|
+
subTitles: parseArrayOf(value["media:subtitle"], parseSubTitle),
|
|
922
|
+
peerLinks: parseArrayOf(value["media:peerlink"], parsePeerLink),
|
|
923
|
+
locations: parseArrayOf(value["media:location"], parseLocation$1),
|
|
924
|
+
rights: parseSingularOf(value["media:rights"], parseRights),
|
|
925
|
+
scenes: parseSingularOf(value["media:scenes"], parseScenes)
|
|
926
|
+
};
|
|
927
|
+
return trimObject(commonElements);
|
|
928
|
+
};
|
|
929
|
+
const parseContent = (value) => {
|
|
930
|
+
if (!isObject(value)) return;
|
|
931
|
+
const content = {
|
|
932
|
+
url: parseString(value["@url"]),
|
|
933
|
+
fileSize: parseNumber(value["@filesize"]),
|
|
934
|
+
type: parseString(value["@type"]),
|
|
935
|
+
medium: parseString(value["@medium"]),
|
|
936
|
+
isDefault: parseBoolean(value["@isdefault"]),
|
|
937
|
+
expression: parseString(value["@expression"]),
|
|
938
|
+
bitrate: parseNumber(value["@bitrate"]),
|
|
939
|
+
framerate: parseNumber(value["@framerate"]),
|
|
940
|
+
samplingrate: parseNumber(value["@samplingrate"]),
|
|
941
|
+
channels: parseNumber(value["@channels"]),
|
|
942
|
+
duration: parseNumber(value["@duration"]),
|
|
943
|
+
height: parseNumber(value["@height"]),
|
|
944
|
+
width: parseNumber(value["@width"]),
|
|
945
|
+
lang: parseString(value["@lang"]),
|
|
946
|
+
...retrieveCommonElements(value)
|
|
947
|
+
};
|
|
948
|
+
return trimObject(content);
|
|
949
|
+
};
|
|
950
|
+
const parseGroup = (value) => {
|
|
951
|
+
if (!isObject(value)) return;
|
|
952
|
+
const group = {
|
|
953
|
+
contents: parseArrayOf(value["media:content"], parseContent),
|
|
954
|
+
...retrieveCommonElements(value)
|
|
955
|
+
};
|
|
956
|
+
return trimObject(group);
|
|
957
|
+
};
|
|
958
|
+
const retrieveItemOrFeed$3 = (value) => {
|
|
959
|
+
if (!isObject(value)) return;
|
|
960
|
+
const itemOrFeed = {
|
|
961
|
+
group: parseSingularOf(value["media:group"], parseGroup),
|
|
962
|
+
contents: parseArrayOf(value["media:content"], parseContent),
|
|
963
|
+
...retrieveCommonElements(value)
|
|
964
|
+
};
|
|
965
|
+
return trimObject(itemOrFeed);
|
|
966
|
+
};
|
|
967
|
+
|
|
968
|
+
//#endregion
|
|
969
|
+
//#region src/namespaces/psc/parse/utils.ts
|
|
970
|
+
const parseChapter = (value) => {
|
|
971
|
+
if (!isObject(value)) return;
|
|
972
|
+
const chapter = {
|
|
973
|
+
start: parseSingularOf(value["@start"], parseString),
|
|
974
|
+
title: parseSingularOf(value["@title"], parseString),
|
|
975
|
+
href: parseSingularOf(value["@href"], parseString),
|
|
976
|
+
image: parseSingularOf(value["@image"], parseString)
|
|
977
|
+
};
|
|
978
|
+
return trimObject(chapter);
|
|
979
|
+
};
|
|
980
|
+
const parseChapters$1 = (value) => {
|
|
981
|
+
return parseArrayOf(value?.["psc:chapter"], parseChapter);
|
|
982
|
+
};
|
|
983
|
+
const retrieveItem$3 = (value) => {
|
|
984
|
+
if (!isObject(value)) return;
|
|
985
|
+
const item = { chapters: parseSingularOf(value["psc:chapters"], parseChapters$1) };
|
|
986
|
+
return trimObject(item);
|
|
987
|
+
};
|
|
988
|
+
|
|
989
|
+
//#endregion
|
|
990
|
+
//#region src/namespaces/slash/parse/utils.ts
|
|
991
|
+
const parseHitParade = (value) => {
|
|
992
|
+
return parseCsvOf(value, parseNumber);
|
|
993
|
+
};
|
|
994
|
+
const retrieveItem$4 = (value) => {
|
|
995
|
+
if (!isObject(value)) return;
|
|
996
|
+
const item = {
|
|
997
|
+
section: parseSingularOf(value["slash:section"], (value$1) => parseString(retrieveText(value$1))),
|
|
998
|
+
department: parseSingularOf(value["slash:department"], (value$1) => parseString(retrieveText(value$1))),
|
|
999
|
+
comments: parseSingularOf(value["slash:comments"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
1000
|
+
hitParade: parseSingularOf(value["slash:hit_parade"], (value$1) => parseHitParade(retrieveText(value$1)))
|
|
1001
|
+
};
|
|
1002
|
+
return trimObject(item);
|
|
1003
|
+
};
|
|
1004
|
+
|
|
1005
|
+
//#endregion
|
|
1006
|
+
//#region src/namespaces/sy/parse/utils.ts
|
|
1007
|
+
const retrieveFeed$5 = (value) => {
|
|
1008
|
+
if (!isObject(value)) return;
|
|
1009
|
+
const feed = {
|
|
1010
|
+
updatePeriod: parseSingularOf(value["sy:updateperiod"], (value$1) => parseString(retrieveText(value$1))),
|
|
1011
|
+
updateFrequency: parseSingularOf(value["sy:updatefrequency"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
1012
|
+
updateBase: parseSingularOf(value["sy:updatebase"], (value$1) => parseDate(retrieveText(value$1)))
|
|
1013
|
+
};
|
|
1014
|
+
return trimObject(feed);
|
|
1015
|
+
};
|
|
1016
|
+
|
|
1017
|
+
//#endregion
|
|
1018
|
+
//#region src/namespaces/thr/parse/utils.ts
|
|
1019
|
+
const parseInReplyTo = (value) => {
|
|
1020
|
+
if (!isObject(value)) return;
|
|
1021
|
+
const inReplyTo = {
|
|
1022
|
+
ref: parseString(value["@ref"]),
|
|
1023
|
+
href: parseString(value["@href"]),
|
|
1024
|
+
type: parseString(value["@type"]),
|
|
1025
|
+
source: parseString(value["@source"])
|
|
1026
|
+
};
|
|
1027
|
+
return trimObject(inReplyTo);
|
|
1028
|
+
};
|
|
1029
|
+
const retrieveLink = (value) => {
|
|
1030
|
+
if (!isObject(value)) return;
|
|
1031
|
+
const link = {
|
|
1032
|
+
count: parseNumber(value["@thr:count"]),
|
|
1033
|
+
updated: parseDate(value["@thr:updated"])
|
|
1034
|
+
};
|
|
1035
|
+
return trimObject(link);
|
|
1036
|
+
};
|
|
1037
|
+
const retrieveItem$6 = (value) => {
|
|
1038
|
+
if (!isObject(value)) return;
|
|
1039
|
+
const item = {
|
|
1040
|
+
total: parseSingularOf(value["thr:total"], (value$1) => parseNumber(retrieveText(value$1))),
|
|
1041
|
+
inReplyTos: parseArrayOf(value["thr:in-reply-to"], parseInReplyTo)
|
|
1042
|
+
};
|
|
1043
|
+
return trimObject(item);
|
|
1044
|
+
};
|
|
1045
|
+
|
|
1046
|
+
//#endregion
|
|
1047
|
+
//#region src/namespaces/wfw/parse/utils.ts
|
|
1048
|
+
const retrieveItem$7 = (value) => {
|
|
1049
|
+
if (!isObject(value)) return;
|
|
1050
|
+
const item = {
|
|
1051
|
+
comment: parseSingularOf(value["wfw:comment"], (value$1) => parseString(retrieveText(value$1))),
|
|
1052
|
+
commentRss: parseSingularOf(value["wfw:commentrss"], (value$1) => parseString(retrieveText(value$1)))
|
|
1053
|
+
};
|
|
1054
|
+
return trimObject(item);
|
|
1055
|
+
};
|
|
1056
|
+
|
|
1057
|
+
//#endregion
|
|
1058
|
+
//#region src/namespaces/yt/parse/utils.ts
|
|
1059
|
+
const retrieveItem$8 = (value) => {
|
|
1060
|
+
if (!isObject(value)) return;
|
|
1061
|
+
const item = {
|
|
1062
|
+
videoId: parseSingularOf(value["yt:videoid"], (value$1) => parseString(retrieveText(value$1))),
|
|
1063
|
+
channelId: parseSingularOf(value["yt:channelid"], (value$1) => parseString(retrieveText(value$1)))
|
|
1064
|
+
};
|
|
1065
|
+
return trimObject(item);
|
|
1066
|
+
};
|
|
1067
|
+
const retrieveFeed$8 = (value) => {
|
|
1068
|
+
if (!isObject(value)) return;
|
|
1069
|
+
const feed = {
|
|
1070
|
+
channelId: parseSingularOf(value["yt:channelid"], (value$1) => parseString(retrieveText(value$1))),
|
|
1071
|
+
playlistId: parseSingularOf(value["yt:playlistid"], (value$1) => parseString(retrieveText(value$1)))
|
|
1072
|
+
};
|
|
1073
|
+
return trimObject(feed);
|
|
1074
|
+
};
|
|
1075
|
+
|
|
1076
|
+
//#endregion
|
|
1077
|
+
//#region src/feeds/atom/parse/utils.ts
|
|
1078
|
+
const createNamespaceGetter = (value, prefix) => {
|
|
1079
|
+
if (!prefix) return (key) => value[key];
|
|
1080
|
+
const prefixedKeys = /* @__PURE__ */ new Map();
|
|
1081
|
+
return (key) => {
|
|
1082
|
+
let prefixedKey = prefixedKeys.get(key);
|
|
1083
|
+
if (!prefixedKey) {
|
|
1084
|
+
prefixedKey = prefix + key;
|
|
1085
|
+
prefixedKeys.set(key, prefixedKey);
|
|
1086
|
+
}
|
|
1087
|
+
return value[prefixedKey];
|
|
1088
|
+
};
|
|
1089
|
+
};
|
|
1090
|
+
const parseLink = (value) => {
|
|
1091
|
+
if (!isObject(value)) return;
|
|
1092
|
+
const link = {
|
|
1093
|
+
href: parseString(value["@href"]),
|
|
1094
|
+
rel: parseString(value["@rel"]),
|
|
1095
|
+
type: parseString(value["@type"]),
|
|
1096
|
+
hreflang: parseString(value["@hreflang"]),
|
|
1097
|
+
title: parseString(value["@title"]),
|
|
1098
|
+
length: parseNumber(value["@length"]),
|
|
1099
|
+
thr: retrieveLink(value)
|
|
1100
|
+
};
|
|
1101
|
+
return trimObject(link);
|
|
1102
|
+
};
|
|
1103
|
+
const retrievePersonUri = (value, options) => {
|
|
1104
|
+
if (!isObject(value)) return;
|
|
1105
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1106
|
+
const uri = parseSingularOf(get("uri"), (value$1) => parseString(retrieveText(value$1)));
|
|
1107
|
+
const url = parseSingularOf(get("url"), (value$1) => parseString(retrieveText(value$1)));
|
|
1108
|
+
return uri || url;
|
|
1109
|
+
};
|
|
1110
|
+
const parsePerson$2 = (value, options) => {
|
|
1111
|
+
if (!isObject(value)) return;
|
|
1112
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1113
|
+
const person = {
|
|
1114
|
+
name: parseSingularOf(get("name"), (value$1) => parseString(retrieveText(value$1))),
|
|
1115
|
+
uri: retrievePersonUri(value, options),
|
|
1116
|
+
email: parseSingularOf(get("email"), (value$1) => parseString(retrieveText(value$1)))
|
|
1117
|
+
};
|
|
1118
|
+
return trimObject(person);
|
|
1119
|
+
};
|
|
1120
|
+
const parseCategory$1 = (value) => {
|
|
1121
|
+
if (!isObject(value)) return;
|
|
1122
|
+
const category = {
|
|
1123
|
+
term: parseString(value["@term"]),
|
|
1124
|
+
scheme: parseString(value["@scheme"]),
|
|
1125
|
+
label: parseString(value["@label"])
|
|
1126
|
+
};
|
|
1127
|
+
return trimObject(category);
|
|
1128
|
+
};
|
|
1129
|
+
const retrieveGeneratorUri = (value) => {
|
|
1130
|
+
if (!isObject(value)) return;
|
|
1131
|
+
const uri = parseString(value["@uri"]);
|
|
1132
|
+
const url = parseString(value["@url"]);
|
|
1133
|
+
return uri || url;
|
|
1134
|
+
};
|
|
1135
|
+
const parseGenerator = (value) => {
|
|
1136
|
+
const generator = {
|
|
1137
|
+
text: parseString(retrieveText(value)),
|
|
1138
|
+
uri: retrieveGeneratorUri(value),
|
|
1139
|
+
version: parseString(value?.["@version"])
|
|
1140
|
+
};
|
|
1141
|
+
return trimObject(generator);
|
|
1142
|
+
};
|
|
1143
|
+
const parseSource$2 = (value, options) => {
|
|
1144
|
+
if (!isObject(value)) return;
|
|
1145
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1146
|
+
const source = {
|
|
1147
|
+
authors: parseArrayOf(get("author"), (value$1) => parsePerson$2(value$1, options)),
|
|
1148
|
+
categories: parseArrayOf(get("category"), (value$1) => parseCategory$1(value$1, options)),
|
|
1149
|
+
contributors: parseArrayOf(get("contributor"), (value$1) => parsePerson$2(value$1, options)),
|
|
1150
|
+
generator: parseSingularOf(get("generator"), (value$1) => parseGenerator(value$1, options)),
|
|
1151
|
+
icon: parseSingularOf(get("icon"), (value$1) => parseString(retrieveText(value$1))),
|
|
1152
|
+
id: parseSingularOf(get("id"), (value$1) => parseString(retrieveText(value$1))),
|
|
1153
|
+
links: parseArrayOf(get("link"), (value$1) => parseLink(value$1, options)),
|
|
1154
|
+
logo: parseSingularOf(get("logo"), (value$1) => parseString(retrieveText(value$1))),
|
|
1155
|
+
rights: parseSingularOf(get("rights"), (value$1) => parseString(retrieveText(value$1))),
|
|
1156
|
+
subtitle: parseSingularOf(get("subtitle"), (value$1) => parseString(retrieveText(value$1))),
|
|
1157
|
+
title: parseSingularOf(get("title"), (value$1) => parseString(retrieveText(value$1))),
|
|
1158
|
+
updated: retrieveUpdated(value)
|
|
1159
|
+
};
|
|
1160
|
+
return trimObject(source);
|
|
1161
|
+
};
|
|
1162
|
+
const retrievePublished = (value, options) => {
|
|
1163
|
+
if (!isObject(value)) return;
|
|
1164
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1165
|
+
const published = parseSingularOf(get("published"), (value$1) => parseDate(retrieveText(value$1)));
|
|
1166
|
+
const issued = parseSingularOf(get("issued"), (value$1) => parseDate(retrieveText(value$1)));
|
|
1167
|
+
const created = parseSingularOf(get("created"), (value$1) => parseDate(retrieveText(value$1)));
|
|
1168
|
+
return published || issued || created;
|
|
1169
|
+
};
|
|
1170
|
+
const retrieveUpdated = (value, options) => {
|
|
1171
|
+
if (!isObject(value)) return;
|
|
1172
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1173
|
+
const updated = parseSingularOf(get("updated"), (value$1) => parseDate(retrieveText(value$1)));
|
|
1174
|
+
const modified = parseSingularOf(get("modified"), (value$1) => parseDate(retrieveText(value$1)));
|
|
1175
|
+
return updated || modified;
|
|
1176
|
+
};
|
|
1177
|
+
const retrieveSubtitle = (value, options) => {
|
|
1178
|
+
if (!isObject(value)) return;
|
|
1179
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1180
|
+
const subtitle = parseSingularOf(get("subtitle"), (value$1) => parseString(retrieveText(value$1)));
|
|
1181
|
+
const tagline = parseSingularOf(get("tagline"), (value$1) => parseString(retrieveText(value$1)));
|
|
1182
|
+
return subtitle || tagline;
|
|
1183
|
+
};
|
|
1184
|
+
const parseEntry = (value, options) => {
|
|
1185
|
+
if (!isObject(value)) return;
|
|
1186
|
+
const namespaces = options?.asNamespace ? void 0 : detectNamespaces(value);
|
|
1187
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1188
|
+
const entry = {
|
|
1189
|
+
authors: parseArrayOf(get("author"), (value$1) => parsePerson$2(value$1, options)),
|
|
1190
|
+
categories: parseArrayOf(get("category"), (value$1) => parseCategory$1(value$1, options)),
|
|
1191
|
+
content: parseSingularOf(get("content"), (value$1) => parseString(retrieveText(value$1))),
|
|
1192
|
+
contributors: parseArrayOf(get("contributor"), (value$1) => parsePerson$2(value$1, options)),
|
|
1193
|
+
id: parseSingularOf(get("id"), (value$1) => parseString(retrieveText(value$1))),
|
|
1194
|
+
links: parseArrayOf(get("link"), (value$1) => parseLink(value$1, options)),
|
|
1195
|
+
published: retrievePublished(value, options),
|
|
1196
|
+
rights: parseSingularOf(get("rights"), (value$1) => parseString(retrieveText(value$1))),
|
|
1197
|
+
source: parseSingularOf(get("source"), parseSource$2),
|
|
1198
|
+
summary: parseSingularOf(get("summary"), (value$1) => parseString(retrieveText(value$1))),
|
|
1199
|
+
title: parseSingularOf(get("title"), (value$1) => parseString(retrieveText(value$1))),
|
|
1200
|
+
updated: retrieveUpdated(value, options),
|
|
1201
|
+
dc: namespaces?.has("dc") ? retrieveItemOrFeed(value) : void 0,
|
|
1202
|
+
slash: namespaces?.has("slash") ? retrieveItem$4(value) : void 0,
|
|
1203
|
+
itunes: namespaces?.has("itunes") ? retrieveItem$1(value) : void 0,
|
|
1204
|
+
psc: namespaces?.has("psc") ? retrieveItem$3(value) : void 0,
|
|
1205
|
+
media: namespaces?.has("media") ? retrieveItemOrFeed$3(value) : void 0,
|
|
1206
|
+
georss: namespaces?.has("georss") ? retrieveItemOrFeed$2(value) : void 0,
|
|
1207
|
+
thr: namespaces?.has("thr") ? retrieveItem$6(value) : void 0,
|
|
1208
|
+
dcterms: namespaces?.has("dcterms") ? retrieveItemOrFeed$1(value) : void 0,
|
|
1209
|
+
wfw: namespaces?.has("wfw") ? retrieveItem$7(value) : void 0,
|
|
1210
|
+
yt: namespaces?.has("yt") ? retrieveItem$8(value) : void 0
|
|
1211
|
+
};
|
|
1212
|
+
return trimObject(entry);
|
|
1213
|
+
};
|
|
1214
|
+
const parseFeed$2 = (value, options) => {
|
|
1215
|
+
if (!isObject(value)) return;
|
|
1216
|
+
const namespaces = options?.asNamespace ? void 0 : detectNamespaces(value);
|
|
1217
|
+
const get = createNamespaceGetter(value, options?.prefix);
|
|
1218
|
+
const feed = {
|
|
1219
|
+
authors: parseArrayOf(get("author"), (value$1) => parsePerson$2(value$1, options)),
|
|
1220
|
+
categories: parseArrayOf(get("category"), (value$1) => parseCategory$1(value$1, options)),
|
|
1221
|
+
contributors: parseArrayOf(get("contributor"), (value$1) => parsePerson$2(value$1, options)),
|
|
1222
|
+
generator: parseSingularOf(get("generator"), (value$1) => parseGenerator(value$1, options)),
|
|
1223
|
+
icon: parseSingularOf(get("icon"), (value$1) => parseString(retrieveText(value$1))),
|
|
1224
|
+
id: parseSingularOf(get("id"), (value$1) => parseString(retrieveText(value$1))),
|
|
1225
|
+
links: parseArrayOf(get("link"), (value$1) => parseLink(value$1, options)),
|
|
1226
|
+
logo: parseSingularOf(get("logo"), (value$1) => parseString(retrieveText(value$1))),
|
|
1227
|
+
rights: parseSingularOf(get("rights"), (value$1) => parseString(retrieveText(value$1))),
|
|
1228
|
+
subtitle: retrieveSubtitle(value, options),
|
|
1229
|
+
title: parseSingularOf(get("title"), (value$1) => parseString(retrieveText(value$1))),
|
|
1230
|
+
updated: retrieveUpdated(value, options),
|
|
1231
|
+
entries: parseArrayOf(get("entry"), (value$1) => parseEntry(value$1, options)),
|
|
1232
|
+
dc: namespaces?.has("dc") ? retrieveItemOrFeed(value) : void 0,
|
|
1233
|
+
sy: namespaces?.has("sy") ? retrieveFeed$5(value) : void 0,
|
|
1234
|
+
itunes: namespaces?.has("itunes") ? retrieveFeed$2(value) : void 0,
|
|
1235
|
+
media: namespaces?.has("media") ? retrieveItemOrFeed$3(value) : void 0,
|
|
1236
|
+
georss: namespaces?.has("georss") ? retrieveItemOrFeed$2(value) : void 0,
|
|
1237
|
+
dcterms: namespaces?.has("dcterms") ? retrieveItemOrFeed$1(value) : void 0,
|
|
1238
|
+
yt: namespaces?.has("yt") ? retrieveFeed$8(value) : void 0
|
|
1239
|
+
};
|
|
1240
|
+
return trimObject(feed);
|
|
1241
|
+
};
|
|
1242
|
+
const retrieveFeed$7 = (value) => {
|
|
1243
|
+
const notNamespaced = parseSingularOf(value?.feed, parseFeed$2);
|
|
1244
|
+
const namespaced = parseSingularOf(value?.["atom:feed"], (value$1) => parseFeed$2(value$1, { prefix: "atom:" }));
|
|
1245
|
+
return notNamespaced || namespaced;
|
|
1246
|
+
};
|
|
1247
|
+
|
|
1248
|
+
//#endregion
|
|
1249
|
+
//#region src/feeds/atom/parse/index.ts
|
|
1250
|
+
const parse = (value) => {
|
|
1251
|
+
if (!detect(value)) throw new Error(locales.invalid);
|
|
1252
|
+
const normalizeNamespaces = createNamespaceNormalizator(namespaceUrls, namespaceUrls.atom);
|
|
1253
|
+
const object = parser$3.parse(value);
|
|
1254
|
+
const normalized = normalizeNamespaces(object);
|
|
1255
|
+
const parsed = retrieveFeed$7(normalized);
|
|
1256
|
+
if (!parsed) throw new Error(locales.invalid);
|
|
1257
|
+
return parsed;
|
|
1258
|
+
};
|
|
1259
|
+
|
|
1260
|
+
//#endregion
|
|
1261
|
+
//#region src/feeds/json/parse/utils.ts
|
|
1262
|
+
const createCaseInsensitiveGetter = (value) => {
|
|
1263
|
+
return (requestedKey) => {
|
|
1264
|
+
if (requestedKey in value) return value[requestedKey];
|
|
1265
|
+
const lowerKey = requestedKey.toLowerCase();
|
|
1266
|
+
for (const key in value) if (key.toLowerCase() === lowerKey) return value[key];
|
|
1267
|
+
};
|
|
1268
|
+
};
|
|
1269
|
+
const parseAuthor = (value) => {
|
|
1270
|
+
if (isObject(value)) {
|
|
1271
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1272
|
+
const author = {
|
|
1273
|
+
name: parseSingularOf(get("name"), parseString),
|
|
1274
|
+
url: parseSingularOf(get("url"), parseString),
|
|
1275
|
+
avatar: parseSingularOf(get("avatar"), parseString)
|
|
1276
|
+
};
|
|
1277
|
+
return trimObject(author);
|
|
1278
|
+
}
|
|
1279
|
+
if (isNonEmptyStringOrNumber(value)) {
|
|
1280
|
+
const author = { name: parseString(value) };
|
|
1281
|
+
return trimObject(author);
|
|
1282
|
+
}
|
|
1283
|
+
};
|
|
1284
|
+
const retrieveAuthors = (value) => {
|
|
1285
|
+
if (!isObject(value)) return;
|
|
1286
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1287
|
+
const parsedAuthors = parseArrayOf(get("authors"), parseAuthor);
|
|
1288
|
+
const parsedAuthor = parseArrayOf(get("author"), parseAuthor);
|
|
1289
|
+
return parsedAuthors?.length ? parsedAuthors : parsedAuthor;
|
|
1290
|
+
};
|
|
1291
|
+
const parseAttachment = (value) => {
|
|
1292
|
+
if (!isObject(value)) return;
|
|
1293
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1294
|
+
const attachment = {
|
|
1295
|
+
url: parseSingularOf(get("url"), parseString),
|
|
1296
|
+
mime_type: parseSingularOf(get("mime_type"), parseString),
|
|
1297
|
+
title: parseSingularOf(get("title"), parseString),
|
|
1298
|
+
size_in_bytes: parseSingularOf(get("size_in_bytes"), parseNumber),
|
|
1299
|
+
duration_in_seconds: parseSingularOf(get("duration_in_seconds"), parseNumber)
|
|
1300
|
+
};
|
|
1301
|
+
return trimObject(attachment);
|
|
1302
|
+
};
|
|
1303
|
+
const parseItem$2 = (value) => {
|
|
1304
|
+
if (!isObject(value)) return;
|
|
1305
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1306
|
+
const item = {
|
|
1307
|
+
id: parseSingularOf(get("id"), parseString),
|
|
1308
|
+
url: parseSingularOf(get("url"), parseString),
|
|
1309
|
+
external_url: parseSingularOf(get("external_url"), parseString),
|
|
1310
|
+
title: parseSingularOf(get("title"), parseString),
|
|
1311
|
+
content_html: parseSingularOf(get("content_html"), parseString),
|
|
1312
|
+
content_text: parseSingularOf(get("content_text"), parseString),
|
|
1313
|
+
summary: parseSingularOf(get("summary"), parseString),
|
|
1314
|
+
image: parseSingularOf(get("image"), parseString),
|
|
1315
|
+
banner_image: parseSingularOf(get("banner_image"), parseString),
|
|
1316
|
+
date_published: parseSingularOf(get("date_published"), parseDate),
|
|
1317
|
+
date_modified: parseSingularOf(get("date_modified"), parseDate),
|
|
1318
|
+
tags: parseArrayOf(get("tags"), parseString),
|
|
1319
|
+
authors: retrieveAuthors(value),
|
|
1320
|
+
language: parseSingularOf(get("language"), parseString),
|
|
1321
|
+
attachments: parseArrayOf(get("attachments"), parseAttachment)
|
|
1322
|
+
};
|
|
1323
|
+
return trimObject(item);
|
|
1324
|
+
};
|
|
1325
|
+
const parseHub = (value) => {
|
|
1326
|
+
if (!isObject(value)) return;
|
|
1327
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1328
|
+
const hub = {
|
|
1329
|
+
type: parseSingularOf(get("type"), parseString),
|
|
1330
|
+
url: parseSingularOf(get("url"), parseString)
|
|
1331
|
+
};
|
|
1332
|
+
return trimObject(hub);
|
|
1333
|
+
};
|
|
1334
|
+
const parseFeed$3 = (value) => {
|
|
1335
|
+
if (!isObject(value)) return;
|
|
1336
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1337
|
+
const feed = {
|
|
1338
|
+
title: parseSingularOf(get("title"), parseString),
|
|
1339
|
+
home_page_url: parseSingularOf(get("home_page_url"), parseString),
|
|
1340
|
+
feed_url: parseSingularOf(get("feed_url"), parseString),
|
|
1341
|
+
description: parseSingularOf(get("description"), parseString),
|
|
1342
|
+
user_comment: parseSingularOf(get("user_comment"), parseString),
|
|
1343
|
+
next_url: parseSingularOf(get("next_url"), parseString),
|
|
1344
|
+
icon: parseSingularOf(get("icon"), parseString),
|
|
1345
|
+
favicon: parseSingularOf(get("favicon"), parseString),
|
|
1346
|
+
language: parseSingularOf(get("language"), parseString),
|
|
1347
|
+
expired: parseSingularOf(get("expired"), parseBoolean),
|
|
1348
|
+
hubs: parseArrayOf(get("hubs"), parseHub),
|
|
1349
|
+
authors: retrieveAuthors(value),
|
|
1350
|
+
items: parseArrayOf(get("items"), parseItem$2)
|
|
1351
|
+
};
|
|
1352
|
+
return trimObject(feed);
|
|
1353
|
+
};
|
|
1354
|
+
|
|
1355
|
+
//#endregion
|
|
1356
|
+
//#region src/feeds/json/detect/index.ts
|
|
1357
|
+
const detect$1 = (value) => {
|
|
1358
|
+
if (!isObject(value)) return false;
|
|
1359
|
+
const get = createCaseInsensitiveGetter(value);
|
|
1360
|
+
const version = get("version");
|
|
1361
|
+
if (isNonEmptyString(version)) return version.includes("jsonfeed.org/version/");
|
|
1362
|
+
const hasTitle = isNonEmptyString(get("title"));
|
|
1363
|
+
const hasItems = Array.isArray(get("items"));
|
|
1364
|
+
const hasJsonFeedProps = !!(get("home_page_url") || get("feed_url") || get("authors"));
|
|
1365
|
+
return hasTitle && (hasItems || hasJsonFeedProps);
|
|
1366
|
+
};
|
|
1367
|
+
|
|
1368
|
+
//#endregion
|
|
1369
|
+
//#region src/feeds/json/parse/index.ts
|
|
1370
|
+
const parse$2 = (value) => {
|
|
1371
|
+
if (!detect$1(value)) throw new Error(locales.invalid);
|
|
1372
|
+
const parsed = parseFeed$3(value);
|
|
1373
|
+
if (!parsed) throw new Error(locales.invalid);
|
|
1374
|
+
return parsed;
|
|
1375
|
+
};
|
|
1376
|
+
|
|
1377
|
+
//#endregion
|
|
1378
|
+
//#region src/feeds/rdf/detect/index.ts
|
|
1379
|
+
const detect$2 = (value) => {
|
|
1380
|
+
if (!isNonEmptyString(value)) return false;
|
|
1381
|
+
if (!/(?:^|\s|>)\s*<(?:\w+:)?rdf[\s>]/im.test(value)) return false;
|
|
1382
|
+
const hasRdfNamespace = value.includes("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
|
|
1383
|
+
const hasRssNamespace = value.includes("http://purl.org/rss/1.0/");
|
|
1384
|
+
const hasRdfElements = /(<(?:\w+:)?(channel|item|title|link|description)[\s>])/i.test(value);
|
|
1385
|
+
return hasRdfNamespace || hasRssNamespace || hasRdfElements;
|
|
1386
|
+
};
|
|
1387
|
+
|
|
1388
|
+
//#endregion
|
|
1389
|
+
//#region src/feeds/rdf/parse/config.ts
|
|
1390
|
+
const stopNodes$2 = [
|
|
1391
|
+
"rdf:rdf.channel.title",
|
|
1392
|
+
"rdf:rdf.channel.link",
|
|
1393
|
+
"rdf:rdf.channel.description",
|
|
1394
|
+
"rdf:rdf.image.title",
|
|
1395
|
+
"rdf:rdf.image.link",
|
|
1396
|
+
"rdf:rdf.image.url",
|
|
1397
|
+
"rdf:rdf.item.title",
|
|
1398
|
+
"rdf:rdf.item.link",
|
|
1399
|
+
"rdf:rdf.item.description",
|
|
1400
|
+
"rdf:rdf.textinput.title",
|
|
1401
|
+
"rdf:rdf.textinput.description",
|
|
1402
|
+
"rdf:rdf.textinput.name",
|
|
1403
|
+
"rdf:rdf.textinput.link"
|
|
1404
|
+
];
|
|
1405
|
+
const parser$2 = new XMLParser({
|
|
1406
|
+
...parserConfig,
|
|
1407
|
+
stopNodes: stopNodes$2
|
|
1408
|
+
});
|
|
1409
|
+
|
|
1410
|
+
//#endregion
|
|
1411
|
+
//#region src/namespaces/atom/parse/utils.ts
|
|
1412
|
+
const retrieveEntry = (value) => {
|
|
1413
|
+
return parseEntry(value, {
|
|
1414
|
+
prefix: "atom:",
|
|
1415
|
+
asNamespace: true
|
|
1416
|
+
});
|
|
1417
|
+
};
|
|
1418
|
+
const retrieveFeed$1 = (value) => {
|
|
1419
|
+
return parseFeed$2(value, {
|
|
1420
|
+
prefix: "atom:",
|
|
1421
|
+
asNamespace: true
|
|
1422
|
+
});
|
|
1423
|
+
};
|
|
1424
|
+
|
|
1425
|
+
//#endregion
|
|
1426
|
+
//#region src/namespaces/content/parse/utils.ts
|
|
1427
|
+
const retrieveItem = (value) => {
|
|
1428
|
+
if (!isObject(value)) return;
|
|
1429
|
+
const item = { encoded: parseSingularOf(value["content:encoded"], (value$1) => parseString(retrieveText(value$1))) };
|
|
1430
|
+
return trimObject(item);
|
|
1431
|
+
};
|
|
1432
|
+
|
|
1433
|
+
//#endregion
|
|
1434
|
+
//#region src/feeds/rdf/parse/utils.ts
|
|
1435
|
+
const parseImage$1 = (value) => {
|
|
1436
|
+
if (!isObject(value)) return;
|
|
1437
|
+
const image = {
|
|
1438
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1439
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1))),
|
|
1440
|
+
url: parseSingularOf(value.url, (value$1) => parseString(retrieveText(value$1)))
|
|
1441
|
+
};
|
|
1442
|
+
return trimObject(image);
|
|
1443
|
+
};
|
|
1444
|
+
const retrieveImage = (value) => {
|
|
1445
|
+
return parseSingularOf(value?.image, parseImage$1);
|
|
1446
|
+
};
|
|
1447
|
+
const parseTextInput$1 = (value) => {
|
|
1448
|
+
if (!isObject(value)) return;
|
|
1449
|
+
const textInput = {
|
|
1450
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1451
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1452
|
+
name: parseSingularOf(value.name, (value$1) => parseString(retrieveText(value$1))),
|
|
1453
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1)))
|
|
1454
|
+
};
|
|
1455
|
+
return trimObject(textInput);
|
|
1456
|
+
};
|
|
1457
|
+
const retrieveTextInput = (value) => {
|
|
1458
|
+
return parseSingularOf(value?.textinput, parseTextInput$1);
|
|
1459
|
+
};
|
|
1460
|
+
const parseItem$1 = (value) => {
|
|
1461
|
+
if (!isObject(value)) return;
|
|
1462
|
+
const namespaces = detectNamespaces(value);
|
|
1463
|
+
const item = {
|
|
1464
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1465
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1))),
|
|
1466
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1467
|
+
atom: namespaces.has("atom") ? retrieveEntry(value) : void 0,
|
|
1468
|
+
dc: namespaces.has("dc") ? retrieveItemOrFeed(value) : void 0,
|
|
1469
|
+
content: namespaces.has("content") ? retrieveItem(value) : void 0,
|
|
1470
|
+
slash: namespaces.has("slash") ? retrieveItem$4(value) : void 0,
|
|
1471
|
+
media: namespaces.has("media") ? retrieveItemOrFeed$3(value) : void 0,
|
|
1472
|
+
georss: namespaces.has("georss") ? retrieveItemOrFeed$2(value) : void 0,
|
|
1473
|
+
dcterms: namespaces.has("dcterms") ? retrieveItemOrFeed$1(value) : void 0,
|
|
1474
|
+
wfw: namespaces.has("wfw") ? retrieveItem$7(value) : void 0
|
|
1475
|
+
};
|
|
1476
|
+
return trimObject(item);
|
|
1477
|
+
};
|
|
1478
|
+
const retrieveItems = (value) => {
|
|
1479
|
+
return parseArrayOf(value?.item, parseItem$1);
|
|
1480
|
+
};
|
|
1481
|
+
const parseFeed$1 = (value) => {
|
|
1482
|
+
if (!isObject(value)) return;
|
|
1483
|
+
const channel = parseSingular(value.channel);
|
|
1484
|
+
const namespaces = detectNamespaces(channel);
|
|
1485
|
+
const feed = {
|
|
1486
|
+
title: parseSingularOf(channel?.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1487
|
+
link: parseSingularOf(channel?.link, (value$1) => parseString(retrieveText(value$1))),
|
|
1488
|
+
description: parseSingularOf(channel?.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1489
|
+
image: retrieveImage(value),
|
|
1490
|
+
items: retrieveItems(value),
|
|
1491
|
+
textInput: retrieveTextInput(value),
|
|
1492
|
+
atom: namespaces.has("atom") ? retrieveFeed$1(channel) : void 0,
|
|
1493
|
+
dc: namespaces.has("dc") ? retrieveItemOrFeed(channel) : void 0,
|
|
1494
|
+
sy: namespaces.has("sy") ? retrieveFeed$5(channel) : void 0,
|
|
1495
|
+
media: namespaces.has("media") ? retrieveItemOrFeed$3(channel) : void 0,
|
|
1496
|
+
georss: namespaces.has("georss") ? retrieveItemOrFeed$2(channel) : void 0,
|
|
1497
|
+
dcterms: namespaces.has("dcterms") ? retrieveItemOrFeed$1(channel) : void 0
|
|
1498
|
+
};
|
|
1499
|
+
return trimObject(feed);
|
|
1500
|
+
};
|
|
1501
|
+
const retrieveFeed$6 = (value) => {
|
|
1502
|
+
return parseSingularOf(value?.rdf, parseFeed$1);
|
|
1503
|
+
};
|
|
1504
|
+
|
|
1505
|
+
//#endregion
|
|
1506
|
+
//#region src/feeds/rdf/parse/index.ts
|
|
1507
|
+
const parse$4 = (value) => {
|
|
1508
|
+
if (!detect$2(value)) throw new Error(locales.invalid);
|
|
1509
|
+
const normalizeNamespaces = createNamespaceNormalizator(namespaceUrls, namespaceUrls.rdf);
|
|
1510
|
+
const object = parser$2.parse(value);
|
|
1511
|
+
const normalized = normalizeNamespaces(object);
|
|
1512
|
+
const parsed = retrieveFeed$6(normalized);
|
|
1513
|
+
if (!parsed) throw new Error(locales.invalid);
|
|
1514
|
+
return parsed;
|
|
1515
|
+
};
|
|
1516
|
+
|
|
1517
|
+
//#endregion
|
|
1518
|
+
//#region src/feeds/rss/detect/index.ts
|
|
1519
|
+
const detect$3 = (value) => {
|
|
1520
|
+
if (!isNonEmptyString(value)) return false;
|
|
1521
|
+
if (!/(?:^|\s|>)\s*<(?:\w+:)?rss[\s>]/im.test(value)) return false;
|
|
1522
|
+
const hasVersionAttribute = /version\s*=\s*["'][^"']*["']/i.test(value);
|
|
1523
|
+
const hasRssElements = /(<(channel|item|title|link|description|pubDate|guid)[\s>])/i.test(value);
|
|
1524
|
+
return hasVersionAttribute || hasRssElements;
|
|
1525
|
+
};
|
|
1526
|
+
|
|
1527
|
+
//#endregion
|
|
1528
|
+
//#region src/feeds/rss/parse/config.ts
|
|
1529
|
+
const stopNodes$1 = [
|
|
1530
|
+
"rss.channel.title",
|
|
1531
|
+
"rss.channel.link",
|
|
1532
|
+
"rss.channel.description",
|
|
1533
|
+
"rss.channel.language",
|
|
1534
|
+
"rss.channel.copyright",
|
|
1535
|
+
"rss.channel.managingeditor",
|
|
1536
|
+
"rss.channel.webmaster",
|
|
1537
|
+
"rss.channel.pubdate",
|
|
1538
|
+
"rss.channel.lastbuilddate",
|
|
1539
|
+
"rss.channel.author",
|
|
1540
|
+
"rss.channel.category",
|
|
1541
|
+
"rss.channel.generator",
|
|
1542
|
+
"rss.channel.docs",
|
|
1543
|
+
"rss.channel.cloud",
|
|
1544
|
+
"rss.channel.ttl",
|
|
1545
|
+
"rss.channel.image.description",
|
|
1546
|
+
"rss.channel.image.height",
|
|
1547
|
+
"rss.channel.image.link",
|
|
1548
|
+
"rss.channel.image.title",
|
|
1549
|
+
"rss.channel.image.url",
|
|
1550
|
+
"rss.channel.image.width",
|
|
1551
|
+
"rss.channel.rating",
|
|
1552
|
+
"rss.channel.textinput.title",
|
|
1553
|
+
"rss.channel.textinput.description",
|
|
1554
|
+
"rss.channel.textinput.name",
|
|
1555
|
+
"rss.channel.textinput.link",
|
|
1556
|
+
"rss.channel.skiphours.hour",
|
|
1557
|
+
"rss.channel.skipdays.day",
|
|
1558
|
+
"rss.channel.item.title",
|
|
1559
|
+
"rss.channel.item.link",
|
|
1560
|
+
"rss.channel.item.description",
|
|
1561
|
+
"rss.channel.item.author.name",
|
|
1562
|
+
"rss.channel.item.category",
|
|
1563
|
+
"rss.channel.item.comments",
|
|
1564
|
+
"rss.channel.item.enclosure",
|
|
1565
|
+
"rss.channel.item.guid",
|
|
1566
|
+
"rss.channel.item.pubdate",
|
|
1567
|
+
"rss.channel.item.source"
|
|
1568
|
+
];
|
|
1569
|
+
const parser$1 = new XMLParser({
|
|
1570
|
+
...parserConfig,
|
|
1571
|
+
stopNodes: stopNodes$1
|
|
1572
|
+
});
|
|
1573
|
+
|
|
1574
|
+
//#endregion
|
|
1575
|
+
//#region src/namespaces/podcast/parse/utils.ts
|
|
1576
|
+
const parseTranscript = (value) => {
|
|
1577
|
+
if (!isObject(value)) return;
|
|
1578
|
+
const transcript = {
|
|
1579
|
+
url: parseString(value["@url"]),
|
|
1580
|
+
type: parseString(value["@type"]),
|
|
1581
|
+
language: parseString(value["@language"]),
|
|
1582
|
+
rel: parseString(value["@rel"])
|
|
1583
|
+
};
|
|
1584
|
+
return trimObject(transcript);
|
|
1585
|
+
};
|
|
1586
|
+
const parseLocked = (value) => {
|
|
1587
|
+
const locked = {
|
|
1588
|
+
value: parseYesNoBoolean(retrieveText(value)),
|
|
1589
|
+
owner: parseString(value?.["@owner"])
|
|
1590
|
+
};
|
|
1591
|
+
return trimObject(locked);
|
|
1592
|
+
};
|
|
1593
|
+
const parseFunding = (value) => {
|
|
1594
|
+
if (!isObject(value)) return;
|
|
1595
|
+
const funding = {
|
|
1596
|
+
url: parseString(value["@url"]),
|
|
1597
|
+
display: parseString(value["#text"])
|
|
1598
|
+
};
|
|
1599
|
+
return trimObject(funding);
|
|
1600
|
+
};
|
|
1601
|
+
const parseChapters = (value) => {
|
|
1602
|
+
if (!isObject(value)) return;
|
|
1603
|
+
const chapters = {
|
|
1604
|
+
url: parseString(value["@url"]),
|
|
1605
|
+
type: parseString(value["@type"])
|
|
1606
|
+
};
|
|
1607
|
+
return trimObject(chapters);
|
|
1608
|
+
};
|
|
1609
|
+
const parseSoundbite = (value) => {
|
|
1610
|
+
if (!isObject(value)) return;
|
|
1611
|
+
const soundbite = {
|
|
1612
|
+
startTime: parseNumber(value["@starttime"]),
|
|
1613
|
+
duration: parseNumber(value["@duration"]),
|
|
1614
|
+
display: parseString(retrieveText(value))
|
|
1615
|
+
};
|
|
1616
|
+
return trimObject(soundbite);
|
|
1617
|
+
};
|
|
1618
|
+
const parsePerson$1 = (value) => {
|
|
1619
|
+
const person = {
|
|
1620
|
+
display: parseString(retrieveText(value)),
|
|
1621
|
+
role: parseString(value?.["@role"]),
|
|
1622
|
+
group: parseString(value?.["@group"]),
|
|
1623
|
+
img: parseString(value?.["@img"]),
|
|
1624
|
+
href: parseString(value?.["@href"])
|
|
1625
|
+
};
|
|
1626
|
+
return trimObject(person);
|
|
1627
|
+
};
|
|
1628
|
+
const parseLocation = (value) => {
|
|
1629
|
+
const location = {
|
|
1630
|
+
display: parseString(retrieveText(value)),
|
|
1631
|
+
geo: parseString(value?.["@geo"]),
|
|
1632
|
+
osm: parseString(value?.["@osm"])
|
|
1633
|
+
};
|
|
1634
|
+
return trimObject(location);
|
|
1635
|
+
};
|
|
1636
|
+
const parseSeason = (value) => {
|
|
1637
|
+
const season = {
|
|
1638
|
+
number: parseNumber(retrieveText(value)),
|
|
1639
|
+
name: parseString(value?.["@name"])
|
|
1640
|
+
};
|
|
1641
|
+
return trimObject(season);
|
|
1642
|
+
};
|
|
1643
|
+
const parseEpisode = (value) => {
|
|
1644
|
+
const episode = {
|
|
1645
|
+
number: parseNumber(retrieveText(value)),
|
|
1646
|
+
display: parseString(value?.["@display"])
|
|
1647
|
+
};
|
|
1648
|
+
return trimObject(episode);
|
|
1649
|
+
};
|
|
1650
|
+
const parseTrailer = (value) => {
|
|
1651
|
+
if (!isObject(value)) return;
|
|
1652
|
+
const trailer = {
|
|
1653
|
+
display: parseString(retrieveText(value)),
|
|
1654
|
+
url: parseString(value["@url"]),
|
|
1655
|
+
pubDate: parseDate(value["@pubdate"]),
|
|
1656
|
+
length: parseNumber(value["@length"]),
|
|
1657
|
+
type: parseString(value["@type"]),
|
|
1658
|
+
season: parseNumber(value["@season"])
|
|
1659
|
+
};
|
|
1660
|
+
return trimObject(trailer);
|
|
1661
|
+
};
|
|
1662
|
+
const parseLicense = (value) => {
|
|
1663
|
+
const license = {
|
|
1664
|
+
display: parseString(retrieveText(value)),
|
|
1665
|
+
url: parseString(value?.["@url"])
|
|
1666
|
+
};
|
|
1667
|
+
return trimObject(license);
|
|
1668
|
+
};
|
|
1669
|
+
const parseAlternateEnclosure = (value) => {
|
|
1670
|
+
if (!isObject(value)) return;
|
|
1671
|
+
const alternateEnclosure = {
|
|
1672
|
+
type: parseString(value["@type"]),
|
|
1673
|
+
length: parseNumber(value["@length"]),
|
|
1674
|
+
bitrate: parseNumber(value["@bitrate"]),
|
|
1675
|
+
height: parseNumber(value["@height"]),
|
|
1676
|
+
lang: parseString(value["@lang"]),
|
|
1677
|
+
title: parseString(value["@title"]),
|
|
1678
|
+
rel: parseString(value["@rel"]),
|
|
1679
|
+
codecs: parseString(value["@codecs"]),
|
|
1680
|
+
default: parseBoolean(value["@default"]),
|
|
1681
|
+
sources: parseArrayOf(value["podcast:source"], parseSource$1),
|
|
1682
|
+
integrity: parseSingularOf(value["podcast:integrity"], parseIntegrity)
|
|
1683
|
+
};
|
|
1684
|
+
return trimObject(alternateEnclosure);
|
|
1685
|
+
};
|
|
1686
|
+
const parseSource$1 = (value) => {
|
|
1687
|
+
if (!isObject(value)) return;
|
|
1688
|
+
const source = {
|
|
1689
|
+
uri: parseString(value["@uri"]),
|
|
1690
|
+
contentType: parseString(value["@contenttype"])
|
|
1691
|
+
};
|
|
1692
|
+
return trimObject(source);
|
|
1693
|
+
};
|
|
1694
|
+
const parseIntegrity = (value) => {
|
|
1695
|
+
if (!isObject(value)) return;
|
|
1696
|
+
const integrity = {
|
|
1697
|
+
type: parseString(value["@type"]),
|
|
1698
|
+
value: parseString(value["@value"])
|
|
1699
|
+
};
|
|
1700
|
+
return trimObject(integrity);
|
|
1701
|
+
};
|
|
1702
|
+
const parseValue = (value) => {
|
|
1703
|
+
if (!isObject(value)) return;
|
|
1704
|
+
const parsed = {
|
|
1705
|
+
type: parseString(value["@type"]),
|
|
1706
|
+
method: parseString(value["@method"]),
|
|
1707
|
+
suggested: parseNumber(value["@suggested"]),
|
|
1708
|
+
valueRecipients: parseArrayOf(value["podcast:valuerecipient"], parseValueRecipient),
|
|
1709
|
+
valueTimeSplits: parseArrayOf(value["podcast:valuetimesplit"], parseValueTimeSplit)
|
|
1710
|
+
};
|
|
1711
|
+
return trimObject(parsed);
|
|
1712
|
+
};
|
|
1713
|
+
const parseValueRecipient = (value) => {
|
|
1714
|
+
if (!isObject(value)) return;
|
|
1715
|
+
const valueRecipient = {
|
|
1716
|
+
name: parseString(value["@name"]),
|
|
1717
|
+
customKey: parseString(value["@customkey"]),
|
|
1718
|
+
customValue: parseString(value["@customvalue"]),
|
|
1719
|
+
type: parseString(value["@type"]),
|
|
1720
|
+
address: parseString(value["@address"]),
|
|
1721
|
+
split: parseNumber(value["@split"]),
|
|
1722
|
+
fee: parseBoolean(value["@fee"])
|
|
1723
|
+
};
|
|
1724
|
+
return trimObject(valueRecipient);
|
|
1725
|
+
};
|
|
1726
|
+
const parseImages = (value) => {
|
|
1727
|
+
if (!isObject(value)) return;
|
|
1728
|
+
const images = { srcset: parseString(value["@srcset"]) };
|
|
1729
|
+
return trimObject(images);
|
|
1730
|
+
};
|
|
1731
|
+
const parseLiveItem = (value) => {
|
|
1732
|
+
if (!isObject(value)) return;
|
|
1733
|
+
const liveItem = {
|
|
1734
|
+
...retrieveItem$2(value),
|
|
1735
|
+
status: parseString(value["@status"]),
|
|
1736
|
+
start: parseDate(value["@start"]),
|
|
1737
|
+
end: parseDate(value["@end"]),
|
|
1738
|
+
contentLinks: parseArrayOf(value["podcast:contentlink"], parseContentLink)
|
|
1739
|
+
};
|
|
1740
|
+
return trimObject(liveItem);
|
|
1741
|
+
};
|
|
1742
|
+
const parseContentLink = (value) => {
|
|
1743
|
+
if (!isObject(value)) return;
|
|
1744
|
+
const contentLink = {
|
|
1745
|
+
href: parseString(value["@href"]),
|
|
1746
|
+
display: parseString(retrieveText(value))
|
|
1747
|
+
};
|
|
1748
|
+
return trimObject(contentLink);
|
|
1749
|
+
};
|
|
1750
|
+
const parseSocialInteract = (value) => {
|
|
1751
|
+
if (!isObject(value)) return;
|
|
1752
|
+
const socialInteract = {
|
|
1753
|
+
uri: parseString(value["@uri"]),
|
|
1754
|
+
protocol: parseString(value["@protocol"]),
|
|
1755
|
+
accountId: parseString(value["@accountid"]),
|
|
1756
|
+
accountUrl: parseString(value["@accounturl"]),
|
|
1757
|
+
priority: parseNumber(value["@priority"])
|
|
1758
|
+
};
|
|
1759
|
+
return trimObject(socialInteract);
|
|
1760
|
+
};
|
|
1761
|
+
const parseBlock = (value) => {
|
|
1762
|
+
const block = {
|
|
1763
|
+
value: parseYesNoBoolean(retrieveText(value)),
|
|
1764
|
+
id: parseString(value?.["@id"])
|
|
1765
|
+
};
|
|
1766
|
+
return trimObject(block);
|
|
1767
|
+
};
|
|
1768
|
+
const parseTxt = (value) => {
|
|
1769
|
+
const txt = {
|
|
1770
|
+
display: parseString(retrieveText(value)),
|
|
1771
|
+
purpose: parseString(value?.["@purpose"])
|
|
1772
|
+
};
|
|
1773
|
+
return trimObject(txt);
|
|
1774
|
+
};
|
|
1775
|
+
const parseRemoteItem = (value) => {
|
|
1776
|
+
if (!isObject(value)) return;
|
|
1777
|
+
const remoteItem = {
|
|
1778
|
+
feedGuid: parseString(value["@feedguid"]),
|
|
1779
|
+
feedUrl: parseString(value["@feedurl"]),
|
|
1780
|
+
itemGuid: parseString(value["@itemguid"]),
|
|
1781
|
+
medium: parseString(value["@medium"])
|
|
1782
|
+
};
|
|
1783
|
+
return trimObject(remoteItem);
|
|
1784
|
+
};
|
|
1785
|
+
const parsePodroll = (value) => {
|
|
1786
|
+
if (!isObject(value)) return;
|
|
1787
|
+
const podroll = { remoteItems: parseArrayOf(value["podcast:remoteitem"], parseRemoteItem) };
|
|
1788
|
+
return trimObject(podroll);
|
|
1789
|
+
};
|
|
1790
|
+
const parseUpdateFrequency = (value) => {
|
|
1791
|
+
const updateFrequency = {
|
|
1792
|
+
display: parseString(retrieveText(value)),
|
|
1793
|
+
complete: parseBoolean(value?.["@complete"]),
|
|
1794
|
+
dtstart: parseDate(value?.["@dtstart"]),
|
|
1795
|
+
rrule: parseString(value?.["@rrule"])
|
|
1796
|
+
};
|
|
1797
|
+
return trimObject(updateFrequency);
|
|
1798
|
+
};
|
|
1799
|
+
const parsePodping = (value) => {
|
|
1800
|
+
if (!isObject(value)) return;
|
|
1801
|
+
const podping = { usesPodping: parseBoolean(value["@usespodping"]) };
|
|
1802
|
+
return trimObject(podping);
|
|
1803
|
+
};
|
|
1804
|
+
const parseValueTimeSplit = (value) => {
|
|
1805
|
+
if (!isObject(value)) return;
|
|
1806
|
+
const valueTimeSplit = {
|
|
1807
|
+
startTime: parseNumber(value["@starttime"]),
|
|
1808
|
+
duration: parseNumber(value["@duration"]),
|
|
1809
|
+
remoteStartTime: parseNumber(value["@remotestarttime"]),
|
|
1810
|
+
remotePercentage: parseNumber(value["@remotepercentage"]),
|
|
1811
|
+
remoteItem: parseSingularOf(value["podcast:remoteitem"], parseRemoteItem),
|
|
1812
|
+
valueRecipients: parseArrayOf(value["podcast:valuerecipient"], parseValueRecipient)
|
|
1813
|
+
};
|
|
1814
|
+
return trimObject(valueTimeSplit);
|
|
1815
|
+
};
|
|
1816
|
+
const retrieveItem$2 = (value) => {
|
|
1817
|
+
if (!isObject(value)) return;
|
|
1818
|
+
const item = {
|
|
1819
|
+
transcripts: parseArrayOf(value["podcast:transcript"], parseTranscript),
|
|
1820
|
+
chapters: parseSingularOf(value["podcast:chapters"], parseChapters),
|
|
1821
|
+
soundbites: parseArrayOf(value["podcast:soundbite"], parseSoundbite),
|
|
1822
|
+
persons: parseArrayOf(value["podcast:person"], parsePerson$1),
|
|
1823
|
+
location: parseSingularOf(value["podcast:location"], parseLocation),
|
|
1824
|
+
season: parseSingularOf(value["podcast:season"], parseSeason),
|
|
1825
|
+
episode: parseSingularOf(value["podcast:episode"], parseEpisode),
|
|
1826
|
+
license: parseSingularOf(value["podcast:license"], parseLicense),
|
|
1827
|
+
alternateEnclosures: parseArrayOf(value["podcast:alternateenclosure"], parseAlternateEnclosure),
|
|
1828
|
+
value: parseSingularOf(value["podcast:value"], parseValue),
|
|
1829
|
+
images: parseSingularOf(value["podcast:images"], parseImages),
|
|
1830
|
+
socialInteracts: parseArrayOf(value["podcast:socialinteract"], parseSocialInteract),
|
|
1831
|
+
txts: parseArrayOf(value["podcast:txt"], parseTxt)
|
|
1832
|
+
};
|
|
1833
|
+
return trimObject(item);
|
|
1834
|
+
};
|
|
1835
|
+
const retrieveFeed$3 = (value) => {
|
|
1836
|
+
if (!isObject(value)) return;
|
|
1837
|
+
const feed = {
|
|
1838
|
+
locked: parseSingularOf(value["podcast:locked"], parseLocked),
|
|
1839
|
+
fundings: parseArrayOf(value["podcast:funding"], parseFunding),
|
|
1840
|
+
persons: parseArrayOf(value["podcast:person"], parsePerson$1),
|
|
1841
|
+
location: parseSingularOf(value["podcast:location"], parseLocation),
|
|
1842
|
+
trailers: parseArrayOf(value["podcast:trailer"], parseTrailer),
|
|
1843
|
+
license: parseSingularOf(value["podcast:license"], parseLicense),
|
|
1844
|
+
guid: parseSingularOf(value["podcast:guid"], (value$1) => parseString(retrieveText(value$1))),
|
|
1845
|
+
value: parseSingularOf(value["podcast:value"], parseValue),
|
|
1846
|
+
medium: parseSingularOf(value["podcast:medium"], (value$1) => parseString(retrieveText(value$1))),
|
|
1847
|
+
images: parseSingularOf(value["podcast:images"], parseImages),
|
|
1848
|
+
liveItems: parseArrayOf(value["podcast:liveitem"], parseLiveItem),
|
|
1849
|
+
blocks: parseArrayOf(value["podcast:block"], parseBlock),
|
|
1850
|
+
txts: parseArrayOf(value["podcast:txt"], parseTxt),
|
|
1851
|
+
remoteItems: parseArrayOf(value["podcast:remoteitem"], parseRemoteItem),
|
|
1852
|
+
podroll: parseSingularOf(value["podcast:podroll"], parsePodroll),
|
|
1853
|
+
updateFrequency: parseSingularOf(value["podcast:updatefrequency"], parseUpdateFrequency),
|
|
1854
|
+
podping: parseSingularOf(value["podcast:podping"], parsePodping)
|
|
1855
|
+
};
|
|
1856
|
+
return trimObject(feed);
|
|
1857
|
+
};
|
|
1858
|
+
|
|
1859
|
+
//#endregion
|
|
1860
|
+
//#region src/namespaces/source/parse/utils.ts
|
|
1861
|
+
const parseAccount = (value) => {
|
|
1862
|
+
if (!isObject(value)) return;
|
|
1863
|
+
const account = {
|
|
1864
|
+
service: parseString(value["@service"]),
|
|
1865
|
+
value: parseString(retrieveText(value))
|
|
1866
|
+
};
|
|
1867
|
+
return trimObject(account);
|
|
1868
|
+
};
|
|
1869
|
+
const parseLikes = (value) => {
|
|
1870
|
+
if (!isObject(value)) return;
|
|
1871
|
+
const likes = { server: parseString(value["@server"]) };
|
|
1872
|
+
return trimObject(likes);
|
|
1873
|
+
};
|
|
1874
|
+
const parseArchive = (value) => {
|
|
1875
|
+
if (!isObject(value)) return;
|
|
1876
|
+
const archive = {
|
|
1877
|
+
url: parseSingularOf(value["source:url"], (value$1) => parseString(retrieveText(value$1))),
|
|
1878
|
+
startDay: parseSingularOf(value["source:startday"], (value$1) => parseString(retrieveText(value$1))),
|
|
1879
|
+
endDay: parseSingularOf(value["source:endday"], (value$1) => parseString(retrieveText(value$1))),
|
|
1880
|
+
filename: parseSingularOf(value["source:filename"], (value$1) => parseString(retrieveText(value$1)))
|
|
1881
|
+
};
|
|
1882
|
+
return trimObject(archive);
|
|
1883
|
+
};
|
|
1884
|
+
const parseSubscriptionList = (value) => {
|
|
1885
|
+
if (!isObject(value)) return;
|
|
1886
|
+
const subscriptionList = {
|
|
1887
|
+
url: parseString(value["@url"]),
|
|
1888
|
+
value: parseString(retrieveText(value))
|
|
1889
|
+
};
|
|
1890
|
+
return trimObject(subscriptionList);
|
|
1891
|
+
};
|
|
1892
|
+
const retrieveFeed$4 = (value) => {
|
|
1893
|
+
if (!isObject(value)) return;
|
|
1894
|
+
const feed = {
|
|
1895
|
+
accounts: parseArrayOf(value["source:account"], parseAccount),
|
|
1896
|
+
likes: parseSingularOf(value["source:likes"], parseLikes),
|
|
1897
|
+
archive: parseSingularOf(value["source:archive"], parseArchive),
|
|
1898
|
+
subscriptionLists: parseArrayOf(value["source:subscriptionlist"], parseSubscriptionList),
|
|
1899
|
+
cloud: parseSingularOf(value["source:cloud"], (value$1) => parseString(retrieveText(value$1))),
|
|
1900
|
+
blogroll: parseSingularOf(value["source:blogroll"], (value$1) => parseString(retrieveText(value$1))),
|
|
1901
|
+
self: parseSingularOf(value["source:self"], (value$1) => parseString(retrieveText(value$1)))
|
|
1902
|
+
};
|
|
1903
|
+
return trimObject(feed);
|
|
1904
|
+
};
|
|
1905
|
+
const retrieveItem$5 = (value) => {
|
|
1906
|
+
if (!isObject(value)) return;
|
|
1907
|
+
const item = {
|
|
1908
|
+
markdown: parseSingularOf(value["source:markdown"], (value$1) => parseString(retrieveText(value$1))),
|
|
1909
|
+
outlines: parseArrayOf(value["source:outline"], (value$1) => parseString(retrieveText(value$1))),
|
|
1910
|
+
localTime: parseSingularOf(value["source:localtime"], (value$1) => parseString(retrieveText(value$1))),
|
|
1911
|
+
linkFull: parseSingularOf(value["source:linkfull"], (value$1) => parseString(retrieveText(value$1)))
|
|
1912
|
+
};
|
|
1913
|
+
return trimObject(item);
|
|
1914
|
+
};
|
|
1915
|
+
|
|
1916
|
+
//#endregion
|
|
1917
|
+
//#region src/feeds/rss/parse/utils.ts
|
|
1918
|
+
const parsePerson = (value) => {
|
|
1919
|
+
return parseSingularOf(value?.name ?? value, (value$1) => parseString(retrieveText(value$1)));
|
|
1920
|
+
};
|
|
1921
|
+
const parseCategory = (value) => {
|
|
1922
|
+
const category = {
|
|
1923
|
+
name: parseString(retrieveText(value)),
|
|
1924
|
+
domain: parseString(value?.["@domain"])
|
|
1925
|
+
};
|
|
1926
|
+
return trimObject(category);
|
|
1927
|
+
};
|
|
1928
|
+
const parseCloud = (value) => {
|
|
1929
|
+
if (!isObject(value)) return;
|
|
1930
|
+
const cloud = {
|
|
1931
|
+
domain: parseString(value["@domain"]),
|
|
1932
|
+
port: parseNumber(value["@port"]),
|
|
1933
|
+
path: parseString(value["@path"]),
|
|
1934
|
+
registerProcedure: parseString(value["@registerprocedure"]),
|
|
1935
|
+
protocol: parseString(value["@protocol"])
|
|
1936
|
+
};
|
|
1937
|
+
return trimObject(cloud);
|
|
1938
|
+
};
|
|
1939
|
+
const parseImage = (value) => {
|
|
1940
|
+
if (!isObject(value)) return;
|
|
1941
|
+
const image = {
|
|
1942
|
+
url: parseSingularOf(value.url, (value$1) => parseString(retrieveText(value$1))),
|
|
1943
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1944
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1))),
|
|
1945
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1946
|
+
height: parseSingularOf(value.height, (value$1) => parseNumber(retrieveText(value$1))),
|
|
1947
|
+
width: parseSingularOf(value.width, (value$1) => parseNumber(retrieveText(value$1)))
|
|
1948
|
+
};
|
|
1949
|
+
return trimObject(image);
|
|
1950
|
+
};
|
|
1951
|
+
const parseTextInput = (value) => {
|
|
1952
|
+
if (!isObject(value)) return;
|
|
1953
|
+
const textInput = {
|
|
1954
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1955
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1956
|
+
name: parseSingularOf(value.name, (value$1) => parseString(retrieveText(value$1))),
|
|
1957
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1)))
|
|
1958
|
+
};
|
|
1959
|
+
return trimObject(textInput);
|
|
1960
|
+
};
|
|
1961
|
+
const parseSkipHours = (value) => {
|
|
1962
|
+
return trimArray(value?.hour, (value$1) => parseNumber(retrieveText(value$1)));
|
|
1963
|
+
};
|
|
1964
|
+
const parseSkipDays = (value) => {
|
|
1965
|
+
return trimArray(value?.day, (value$1) => parseString(retrieveText(value$1)));
|
|
1966
|
+
};
|
|
1967
|
+
const parseEnclosure = (value) => {
|
|
1968
|
+
if (!isObject(value)) return;
|
|
1969
|
+
const enclosure = {
|
|
1970
|
+
url: parseString(value["@url"]),
|
|
1971
|
+
length: parseNumber(value["@length"]),
|
|
1972
|
+
type: parseString(value["@type"])
|
|
1973
|
+
};
|
|
1974
|
+
return trimObject(enclosure);
|
|
1975
|
+
};
|
|
1976
|
+
const parseGuid = (value) => {
|
|
1977
|
+
const source = {
|
|
1978
|
+
value: parseString(retrieveText(value)),
|
|
1979
|
+
isPermaLink: parseBoolean(value?.["@ispermalink"])
|
|
1980
|
+
};
|
|
1981
|
+
return trimObject(source);
|
|
1982
|
+
};
|
|
1983
|
+
const parseSource = (value) => {
|
|
1984
|
+
const source = {
|
|
1985
|
+
title: parseString(retrieveText(value)),
|
|
1986
|
+
url: parseString(value?.["@url"])
|
|
1987
|
+
};
|
|
1988
|
+
return trimObject(source);
|
|
1989
|
+
};
|
|
1990
|
+
const parseItem = (value) => {
|
|
1991
|
+
if (!isObject(value)) return;
|
|
1992
|
+
const namespaces = detectNamespaces(value);
|
|
1993
|
+
const item = {
|
|
1994
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
1995
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1))),
|
|
1996
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
1997
|
+
authors: parseArrayOf(value.author, parsePerson),
|
|
1998
|
+
categories: parseArrayOf(value.category, parseCategory),
|
|
1999
|
+
comments: parseSingularOf(value.comments, (value$1) => parseString(retrieveText(value$1))),
|
|
2000
|
+
enclosures: parseArrayOf(value.enclosure, parseEnclosure),
|
|
2001
|
+
guid: parseSingularOf(value.guid, parseGuid),
|
|
2002
|
+
pubDate: parseSingularOf(value.pubdate, (value$1) => parseDate(retrieveText(value$1))),
|
|
2003
|
+
source: parseSingularOf(value.source, parseSource),
|
|
2004
|
+
atom: namespaces.has("atom") ? retrieveEntry(value) : void 0,
|
|
2005
|
+
dc: namespaces.has("dc") ? retrieveItemOrFeed(value) : void 0,
|
|
2006
|
+
content: namespaces.has("content") ? retrieveItem(value) : void 0,
|
|
2007
|
+
slash: namespaces.has("slash") ? retrieveItem$4(value) : void 0,
|
|
2008
|
+
itunes: namespaces.has("itunes") ? retrieveItem$1(value) : void 0,
|
|
2009
|
+
podcast: namespaces.has("podcast") ? retrieveItem$2(value) : void 0,
|
|
2010
|
+
psc: namespaces.has("psc") ? retrieveItem$3(value) : void 0,
|
|
2011
|
+
media: namespaces.has("media") ? retrieveItemOrFeed$3(value) : void 0,
|
|
2012
|
+
georss: namespaces.has("georss") ? retrieveItemOrFeed$2(value) : void 0,
|
|
2013
|
+
thr: namespaces.has("thr") ? retrieveItem$6(value) : void 0,
|
|
2014
|
+
dcterms: namespaces.has("dcterms") ? retrieveItemOrFeed$1(value) : void 0,
|
|
2015
|
+
wfw: namespaces.has("wfw") ? retrieveItem$7(value) : void 0,
|
|
2016
|
+
src: namespaces.has("source") ? retrieveItem$5(value) : void 0
|
|
2017
|
+
};
|
|
2018
|
+
return trimObject(item);
|
|
2019
|
+
};
|
|
2020
|
+
const parseFeed = (value) => {
|
|
2021
|
+
if (!isObject(value)) return;
|
|
2022
|
+
const namespaces = detectNamespaces(value);
|
|
2023
|
+
const feed = {
|
|
2024
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
2025
|
+
link: parseSingularOf(value.link, (value$1) => parseString(retrieveText(value$1))),
|
|
2026
|
+
description: parseSingularOf(value.description, (value$1) => parseString(retrieveText(value$1))),
|
|
2027
|
+
language: parseSingularOf(value.language, (value$1) => parseString(retrieveText(value$1))),
|
|
2028
|
+
copyright: parseSingularOf(value.copyright, (value$1) => parseString(retrieveText(value$1))),
|
|
2029
|
+
managingEditor: parseSingularOf(value.managingeditor, parsePerson),
|
|
2030
|
+
webMaster: parseSingularOf(value.webmaster, parsePerson),
|
|
2031
|
+
pubDate: parseSingularOf(value.pubdate, (value$1) => parseDate(retrieveText(value$1))),
|
|
2032
|
+
lastBuildDate: parseSingularOf(value.lastbuilddate, (value$1) => parseDate(retrieveText(value$1))),
|
|
2033
|
+
categories: parseArrayOf(value.category, parseCategory),
|
|
2034
|
+
generator: parseSingularOf(value.generator, (value$1) => parseString(retrieveText(value$1))),
|
|
2035
|
+
docs: parseSingularOf(value.docs, (value$1) => parseString(retrieveText(value$1))),
|
|
2036
|
+
cloud: parseSingularOf(value.cloud, parseCloud),
|
|
2037
|
+
ttl: parseSingularOf(value.ttl, (value$1) => parseNumber(retrieveText(value$1))),
|
|
2038
|
+
image: parseSingularOf(value.image, parseImage),
|
|
2039
|
+
rating: parseSingularOf(value.rating, (value$1) => parseString(retrieveText(value$1))),
|
|
2040
|
+
textInput: parseSingularOf(value.textinput, parseTextInput),
|
|
2041
|
+
skipHours: parseSingularOf(value.skiphours, parseSkipHours),
|
|
2042
|
+
skipDays: parseSingularOf(value.skipdays, parseSkipDays),
|
|
2043
|
+
items: parseArrayOf(value.item, parseItem),
|
|
2044
|
+
atom: namespaces.has("atom") ? retrieveFeed$1(value) : void 0,
|
|
2045
|
+
dc: namespaces.has("dc") ? retrieveItemOrFeed(value) : void 0,
|
|
2046
|
+
sy: namespaces.has("sy") ? retrieveFeed$5(value) : void 0,
|
|
2047
|
+
itunes: namespaces.has("itunes") ? retrieveFeed$2(value) : void 0,
|
|
2048
|
+
podcast: namespaces.has("podcast") ? retrieveFeed$3(value) : void 0,
|
|
2049
|
+
media: namespaces.has("media") ? retrieveItemOrFeed$3(value) : void 0,
|
|
2050
|
+
georss: namespaces.has("georss") ? retrieveItemOrFeed$2(value) : void 0,
|
|
2051
|
+
dcterms: namespaces.has("dcterms") ? retrieveItemOrFeed$1(value) : void 0,
|
|
2052
|
+
src: namespaces.has("source") ? retrieveFeed$4(value) : void 0
|
|
2053
|
+
};
|
|
2054
|
+
return trimObject(feed);
|
|
2055
|
+
};
|
|
2056
|
+
const retrieveFeed = (value) => {
|
|
2057
|
+
return parseSingularOf(value?.rss?.channel, parseFeed);
|
|
2058
|
+
};
|
|
2059
|
+
|
|
2060
|
+
//#endregion
|
|
2061
|
+
//#region src/feeds/rss/parse/index.ts
|
|
2062
|
+
const parse$5 = (value) => {
|
|
2063
|
+
if (!detect$3(value)) throw new Error(locales.invalid);
|
|
2064
|
+
const normalizeNamespaces = createNamespaceNormalizator(namespaceUrls);
|
|
2065
|
+
const object = parser$1.parse(value);
|
|
2066
|
+
const normalized = normalizeNamespaces(object);
|
|
2067
|
+
const parsed = retrieveFeed(normalized);
|
|
2068
|
+
if (!parsed) throw new Error(locales.invalid);
|
|
2069
|
+
return parsed;
|
|
2070
|
+
};
|
|
2071
|
+
|
|
2072
|
+
//#endregion
|
|
2073
|
+
//#region src/common/parse.ts
|
|
2074
|
+
const parse$1 = (value) => {
|
|
2075
|
+
if (detect$3(value)) return {
|
|
2076
|
+
format: "rss",
|
|
2077
|
+
feed: parse$5(value)
|
|
2078
|
+
};
|
|
2079
|
+
if (detect(value)) return {
|
|
2080
|
+
format: "atom",
|
|
2081
|
+
feed: parse(value)
|
|
2082
|
+
};
|
|
2083
|
+
if (detect$2(value)) return {
|
|
2084
|
+
format: "rdf",
|
|
2085
|
+
feed: parse$4(value)
|
|
2086
|
+
};
|
|
2087
|
+
if (detect$1(value)) return {
|
|
2088
|
+
format: "json",
|
|
2089
|
+
feed: parse$2(value)
|
|
2090
|
+
};
|
|
2091
|
+
throw new Error(locales.unrecognized);
|
|
2092
|
+
};
|
|
2093
|
+
|
|
2094
|
+
//#endregion
|
|
2095
|
+
//#region src/feeds/atom/generate/config.ts
|
|
2096
|
+
const builder$2 = new XMLBuilder({ ...builderConfig });
|
|
2097
|
+
|
|
2098
|
+
//#endregion
|
|
2099
|
+
//#region src/namespaces/dc/generate/utils.ts
|
|
2100
|
+
const generateItemOrFeed = (itemOrFeed) => {
|
|
2101
|
+
if (!isObject(itemOrFeed)) return;
|
|
2102
|
+
const value = {
|
|
2103
|
+
"dc:title": generateCdataString(itemOrFeed.title),
|
|
2104
|
+
"dc:creator": generateCdataString(itemOrFeed.creator),
|
|
2105
|
+
"dc:subject": generateCdataString(itemOrFeed.subject),
|
|
2106
|
+
"dc:description": generateCdataString(itemOrFeed.description),
|
|
2107
|
+
"dc:publisher": generateCdataString(itemOrFeed.publisher),
|
|
2108
|
+
"dc:contributor": generateCdataString(itemOrFeed.contributor),
|
|
2109
|
+
"dc:date": generateRfc3339Date(itemOrFeed.date),
|
|
2110
|
+
"dc:type": generateCdataString(itemOrFeed.type),
|
|
2111
|
+
"dc:format": generateCdataString(itemOrFeed.format),
|
|
2112
|
+
"dc:identifier": generateCdataString(itemOrFeed.identifier),
|
|
2113
|
+
"dc:source": generateCdataString(itemOrFeed.source),
|
|
2114
|
+
"dc:language": generateCdataString(itemOrFeed.language),
|
|
2115
|
+
"dc:relation": generateCdataString(itemOrFeed.relation),
|
|
2116
|
+
"dc:coverage": generateCdataString(itemOrFeed.coverage),
|
|
2117
|
+
"dc:rights": generateCdataString(itemOrFeed.rights)
|
|
2118
|
+
};
|
|
2119
|
+
return trimObject(value);
|
|
2120
|
+
};
|
|
2121
|
+
|
|
2122
|
+
//#endregion
|
|
2123
|
+
//#region src/namespaces/dcterms/generate/utils.ts
|
|
2124
|
+
const generateItemOrFeed$1 = (itemOrFeed) => {
|
|
2125
|
+
if (!isObject(itemOrFeed)) return;
|
|
2126
|
+
const value = {
|
|
2127
|
+
"dcterms:abstract": generateCdataString(itemOrFeed.abstract),
|
|
2128
|
+
"dcterms:accessRights": generateCdataString(itemOrFeed.accessRights),
|
|
2129
|
+
"dcterms:accrualMethod": generateCdataString(itemOrFeed.accrualMethod),
|
|
2130
|
+
"dcterms:accrualPeriodicity": generateCdataString(itemOrFeed.accrualPeriodicity),
|
|
2131
|
+
"dcterms:accrualPolicy": generateCdataString(itemOrFeed.accrualPolicy),
|
|
2132
|
+
"dcterms:alternative": generateCdataString(itemOrFeed.alternative),
|
|
2133
|
+
"dcterms:audience": generateCdataString(itemOrFeed.audience),
|
|
2134
|
+
"dcterms:available": generateRfc3339Date(itemOrFeed.available),
|
|
2135
|
+
"dcterms:bibliographicCitation": generateCdataString(itemOrFeed.bibliographicCitation),
|
|
2136
|
+
"dcterms:conformsTo": generateCdataString(itemOrFeed.conformsTo),
|
|
2137
|
+
"dcterms:contributor": generateCdataString(itemOrFeed.contributor),
|
|
2138
|
+
"dcterms:coverage": generateCdataString(itemOrFeed.coverage),
|
|
2139
|
+
"dcterms:created": generateRfc3339Date(itemOrFeed.created),
|
|
2140
|
+
"dcterms:creator": generateCdataString(itemOrFeed.creator),
|
|
2141
|
+
"dcterms:date": generateRfc3339Date(itemOrFeed.date),
|
|
2142
|
+
"dcterms:dateAccepted": generateRfc3339Date(itemOrFeed.dateAccepted),
|
|
2143
|
+
"dcterms:dateCopyrighted": generateRfc3339Date(itemOrFeed.dateCopyrighted),
|
|
2144
|
+
"dcterms:dateSubmitted": generateRfc3339Date(itemOrFeed.dateSubmitted),
|
|
2145
|
+
"dcterms:description": generateCdataString(itemOrFeed.description),
|
|
2146
|
+
"dcterms:educationLevel": generateCdataString(itemOrFeed.educationLevel),
|
|
2147
|
+
"dcterms:extent": generateCdataString(itemOrFeed.extent),
|
|
2148
|
+
"dcterms:format": generateCdataString(itemOrFeed.format),
|
|
2149
|
+
"dcterms:hasFormat": generateCdataString(itemOrFeed.hasFormat),
|
|
2150
|
+
"dcterms:hasPart": generateCdataString(itemOrFeed.hasPart),
|
|
2151
|
+
"dcterms:hasVersion": generateCdataString(itemOrFeed.hasVersion),
|
|
2152
|
+
"dcterms:identifier": generateCdataString(itemOrFeed.identifier),
|
|
2153
|
+
"dcterms:instructionalMethod": generateCdataString(itemOrFeed.instructionalMethod),
|
|
2154
|
+
"dcterms:isFormatOf": generateCdataString(itemOrFeed.isFormatOf),
|
|
2155
|
+
"dcterms:isPartOf": generateCdataString(itemOrFeed.isPartOf),
|
|
2156
|
+
"dcterms:isReferencedBy": generateCdataString(itemOrFeed.isReferencedBy),
|
|
2157
|
+
"dcterms:isReplacedBy": generateCdataString(itemOrFeed.isReplacedBy),
|
|
2158
|
+
"dcterms:isRequiredBy": generateCdataString(itemOrFeed.isRequiredBy),
|
|
2159
|
+
"dcterms:issued": generateRfc3339Date(itemOrFeed.issued),
|
|
2160
|
+
"dcterms:isVersionOf": generateCdataString(itemOrFeed.isVersionOf),
|
|
2161
|
+
"dcterms:language": generateCdataString(itemOrFeed.language),
|
|
2162
|
+
"dcterms:license": generateCdataString(itemOrFeed.license),
|
|
2163
|
+
"dcterms:mediator": generateCdataString(itemOrFeed.mediator),
|
|
2164
|
+
"dcterms:medium": generateCdataString(itemOrFeed.medium),
|
|
2165
|
+
"dcterms:modified": generateRfc3339Date(itemOrFeed.modified),
|
|
2166
|
+
"dcterms:provenance": generateCdataString(itemOrFeed.provenance),
|
|
2167
|
+
"dcterms:publisher": generateCdataString(itemOrFeed.publisher),
|
|
2168
|
+
"dcterms:references": generateCdataString(itemOrFeed.references),
|
|
2169
|
+
"dcterms:relation": generateCdataString(itemOrFeed.relation),
|
|
2170
|
+
"dcterms:replaces": generateCdataString(itemOrFeed.replaces),
|
|
2171
|
+
"dcterms:requires": generateCdataString(itemOrFeed.requires),
|
|
2172
|
+
"dcterms:rights": generateCdataString(itemOrFeed.rights),
|
|
2173
|
+
"dcterms:rightsHolder": generateCdataString(itemOrFeed.rightsHolder),
|
|
2174
|
+
"dcterms:source": generateCdataString(itemOrFeed.source),
|
|
2175
|
+
"dcterms:spatial": generateCdataString(itemOrFeed.spatial),
|
|
2176
|
+
"dcterms:subject": generateCdataString(itemOrFeed.subject),
|
|
2177
|
+
"dcterms:tableOfContents": generateCdataString(itemOrFeed.tableOfContents),
|
|
2178
|
+
"dcterms:temporal": generateCdataString(itemOrFeed.temporal),
|
|
2179
|
+
"dcterms:title": generateCdataString(itemOrFeed.title),
|
|
2180
|
+
"dcterms:type": generateCdataString(itemOrFeed.type),
|
|
2181
|
+
"dcterms:valid": generateRfc3339Date(itemOrFeed.valid)
|
|
2182
|
+
};
|
|
2183
|
+
return trimObject(value);
|
|
2184
|
+
};
|
|
2185
|
+
|
|
2186
|
+
//#endregion
|
|
2187
|
+
//#region src/namespaces/georss/generate/utils.ts
|
|
2188
|
+
const generateLatLngPairs = (points, pairsCount) => {
|
|
2189
|
+
const coordinates = [];
|
|
2190
|
+
for (const point of points) if (typeof point.lat === "number" && typeof point.lng === "number") coordinates.push(`${point.lat} ${point.lng}`);
|
|
2191
|
+
if (coordinates.length === 0) return;
|
|
2192
|
+
const actualPairCount = coordinates.length;
|
|
2193
|
+
if (pairsCount?.min && actualPairCount < pairsCount.min || pairsCount?.max && actualPairCount > pairsCount.max) return;
|
|
2194
|
+
return coordinates.join(" ");
|
|
2195
|
+
};
|
|
2196
|
+
const generatePoint = (point) => {
|
|
2197
|
+
if (!isObject(point)) return;
|
|
2198
|
+
return generateLatLngPairs([point], {
|
|
2199
|
+
min: 1,
|
|
2200
|
+
max: 1
|
|
2201
|
+
});
|
|
2202
|
+
};
|
|
2203
|
+
const generateLine = (line) => {
|
|
2204
|
+
if (!isObject(line)) return;
|
|
2205
|
+
return generateLatLngPairs(line.points, { min: 2 });
|
|
2206
|
+
};
|
|
2207
|
+
const generatePolygon = (polygon) => {
|
|
2208
|
+
if (!isObject(polygon)) return;
|
|
2209
|
+
return generateLatLngPairs(polygon.points, { min: 4 });
|
|
2210
|
+
};
|
|
2211
|
+
const generateBox = (box) => {
|
|
2212
|
+
if (!isObject(box) || !box.lowerCorner || !box.upperCorner) return;
|
|
2213
|
+
return generateLatLngPairs([box.lowerCorner, box.upperCorner], {
|
|
2214
|
+
min: 2,
|
|
2215
|
+
max: 2
|
|
2216
|
+
});
|
|
2217
|
+
};
|
|
2218
|
+
const generateItemOrFeed$2 = (itemOrFeed) => {
|
|
2219
|
+
if (!isObject(itemOrFeed)) return;
|
|
2220
|
+
const value = {
|
|
2221
|
+
"georss:point": generatePoint(itemOrFeed.point),
|
|
2222
|
+
"georss:line": generateLine(itemOrFeed.line),
|
|
2223
|
+
"georss:polygon": generatePolygon(itemOrFeed.polygon),
|
|
2224
|
+
"georss:box": generateBox(itemOrFeed.box),
|
|
2225
|
+
"georss:featureTypeTag": generateCdataString(itemOrFeed.featureTypeTag),
|
|
2226
|
+
"georss:relationshipTag": generateCdataString(itemOrFeed.relationshipTag),
|
|
2227
|
+
"georss:featureName": generateCdataString(itemOrFeed.featureName),
|
|
2228
|
+
"georss:elev": generateNumber(itemOrFeed.elev),
|
|
2229
|
+
"georss:floor": generateNumber(itemOrFeed.floor),
|
|
2230
|
+
"georss:radius": generateNumber(itemOrFeed.radius)
|
|
2231
|
+
};
|
|
2232
|
+
return trimObject(value);
|
|
2233
|
+
};
|
|
2234
|
+
|
|
2235
|
+
//#endregion
|
|
2236
|
+
//#region src/namespaces/itunes/generate/utils.ts
|
|
2237
|
+
const generateImage$1 = (image) => {
|
|
2238
|
+
if (!isNonEmptyString(image)) return;
|
|
2239
|
+
return { "@href": generatePlainString(image) };
|
|
2240
|
+
};
|
|
2241
|
+
const generateCategory$3 = (category) => {
|
|
2242
|
+
if (!isObject(category)) return;
|
|
2243
|
+
const value = {
|
|
2244
|
+
"@text": generatePlainString(category.text),
|
|
2245
|
+
"itunes:category": trimArray(category.categories, generateCategory$3)
|
|
2246
|
+
};
|
|
2247
|
+
return trimObject(value);
|
|
2248
|
+
};
|
|
2249
|
+
const generateOwner = (owner) => {
|
|
2250
|
+
if (!isObject(owner)) return;
|
|
2251
|
+
const value = {
|
|
2252
|
+
"itunes:name": generateCdataString(owner.name),
|
|
2253
|
+
"itunes:email": generateCdataString(owner.email)
|
|
2254
|
+
};
|
|
2255
|
+
return trimObject(value);
|
|
2256
|
+
};
|
|
2257
|
+
const generateItem$1 = (item) => {
|
|
2258
|
+
if (!isObject(item)) return;
|
|
2259
|
+
const value = {
|
|
2260
|
+
"itunes:duration": generateNumber(item.duration),
|
|
2261
|
+
"itunes:image": generateImage$1(item.image),
|
|
2262
|
+
"itunes:explicit": generateYesNoBoolean(item.explicit),
|
|
2263
|
+
"itunes:title": generateCdataString(item.title),
|
|
2264
|
+
"itunes:episode": generateNumber(item.episode),
|
|
2265
|
+
"itunes:season": generateNumber(item.season),
|
|
2266
|
+
"itunes:episodeType": generateCdataString(item.episodeType),
|
|
2267
|
+
"itunes:block": generateYesNoBoolean(item.block),
|
|
2268
|
+
"itunes:summary": generateCdataString(item.summary),
|
|
2269
|
+
"itunes:subtitle": generateCdataString(item.subtitle),
|
|
2270
|
+
"itunes:keywords": generateCsvOf(item.keywords)
|
|
2271
|
+
};
|
|
2272
|
+
return trimObject(value);
|
|
2273
|
+
};
|
|
2274
|
+
const generateFeed$2 = (feed) => {
|
|
2275
|
+
if (!isObject(feed)) return;
|
|
2276
|
+
const value = {
|
|
2277
|
+
"itunes:image": generateImage$1(feed.image),
|
|
2278
|
+
"itunes:category": trimArray(feed.categories, generateCategory$3),
|
|
2279
|
+
"itunes:explicit": generateYesNoBoolean(feed.explicit),
|
|
2280
|
+
"itunes:author": generateCdataString(feed.author),
|
|
2281
|
+
"itunes:title": generateCdataString(feed.title),
|
|
2282
|
+
"itunes:type": generateCdataString(feed.type),
|
|
2283
|
+
"itunes:new-feed-url": generateCdataString(feed.newFeedUrl),
|
|
2284
|
+
"itunes:block": generateYesNoBoolean(feed.block),
|
|
2285
|
+
"itunes:complete": generateYesNoBoolean(feed.complete),
|
|
2286
|
+
"itunes:applepodcastsverify": generateCdataString(feed.applePodcastsVerify),
|
|
2287
|
+
"itunes:summary": generateCdataString(feed.summary),
|
|
2288
|
+
"itunes:subtitle": generateCdataString(feed.subtitle),
|
|
2289
|
+
"itunes:keywords": generateCsvOf(feed.keywords),
|
|
2290
|
+
"itunes:owner": generateOwner(feed.owner)
|
|
2291
|
+
};
|
|
2292
|
+
return trimObject(value);
|
|
2293
|
+
};
|
|
2294
|
+
|
|
2295
|
+
//#endregion
|
|
2296
|
+
//#region src/namespaces/media/generate/utils.ts
|
|
2297
|
+
const generateRating = (rating) => {
|
|
2298
|
+
if (!isObject(rating)) return;
|
|
2299
|
+
const value = {
|
|
2300
|
+
"#text": generateCdataString(rating.value),
|
|
2301
|
+
"@scheme": generatePlainString(rating.scheme)
|
|
2302
|
+
};
|
|
2303
|
+
return trimObject(value);
|
|
2304
|
+
};
|
|
2305
|
+
const generateTitleOrDescription = (titleOrDescription) => {
|
|
2306
|
+
if (!isObject(titleOrDescription)) return;
|
|
2307
|
+
const value = {
|
|
2308
|
+
"#text": generateCdataString(titleOrDescription.value),
|
|
2309
|
+
"@type": generatePlainString(titleOrDescription.type)
|
|
2310
|
+
};
|
|
2311
|
+
return trimObject(value);
|
|
2312
|
+
};
|
|
2313
|
+
const generateThumbnail = (thumbnail) => {
|
|
2314
|
+
if (!isObject(thumbnail)) return;
|
|
2315
|
+
const value = {
|
|
2316
|
+
"@url": generatePlainString(thumbnail.url),
|
|
2317
|
+
"@height": generateNumber(thumbnail.height),
|
|
2318
|
+
"@width": generateNumber(thumbnail.width),
|
|
2319
|
+
"@time": generatePlainString(thumbnail.time)
|
|
2320
|
+
};
|
|
2321
|
+
return trimObject(value);
|
|
2322
|
+
};
|
|
2323
|
+
const generateCategory$2 = (category) => {
|
|
2324
|
+
if (!isObject(category)) return;
|
|
2325
|
+
const value = {
|
|
2326
|
+
"#text": generateCdataString(category.name),
|
|
2327
|
+
"@scheme": generatePlainString(category.scheme),
|
|
2328
|
+
"@label": generatePlainString(category.label)
|
|
2329
|
+
};
|
|
2330
|
+
return trimObject(value);
|
|
2331
|
+
};
|
|
2332
|
+
const generateHash = (hash) => {
|
|
2333
|
+
if (!isObject(hash)) return;
|
|
2334
|
+
const value = {
|
|
2335
|
+
"#text": generateCdataString(hash.value),
|
|
2336
|
+
"@algo": generatePlainString(hash.algo)
|
|
2337
|
+
};
|
|
2338
|
+
return trimObject(value);
|
|
2339
|
+
};
|
|
2340
|
+
const generatePlayer = (player) => {
|
|
2341
|
+
if (!isObject(player)) return;
|
|
2342
|
+
const value = {
|
|
2343
|
+
"@url": generatePlainString(player.url),
|
|
2344
|
+
"@height": generateNumber(player.height),
|
|
2345
|
+
"@width": generateNumber(player.width)
|
|
2346
|
+
};
|
|
2347
|
+
return trimObject(value);
|
|
2348
|
+
};
|
|
2349
|
+
const generateCredit = (credit) => {
|
|
2350
|
+
if (!isObject(credit)) return;
|
|
2351
|
+
const value = {
|
|
2352
|
+
"#text": generateCdataString(credit.value),
|
|
2353
|
+
"@role": generatePlainString(credit.role),
|
|
2354
|
+
"@scheme": generatePlainString(credit.scheme)
|
|
2355
|
+
};
|
|
2356
|
+
return trimObject(value);
|
|
2357
|
+
};
|
|
2358
|
+
const generateCopyright = (copyright) => {
|
|
2359
|
+
if (!isObject(copyright)) return;
|
|
2360
|
+
const value = {
|
|
2361
|
+
"#text": generateCdataString(copyright.value),
|
|
2362
|
+
"@url": generatePlainString(copyright.url)
|
|
2363
|
+
};
|
|
2364
|
+
return trimObject(value);
|
|
2365
|
+
};
|
|
2366
|
+
const generateText$1 = (text) => {
|
|
2367
|
+
if (!isObject(text)) return;
|
|
2368
|
+
const value = {
|
|
2369
|
+
"#text": generateCdataString(text.value),
|
|
2370
|
+
"@type": generatePlainString(text.type),
|
|
2371
|
+
"@lang": generatePlainString(text.lang),
|
|
2372
|
+
"@start": generatePlainString(text.start),
|
|
2373
|
+
"@end": generatePlainString(text.end)
|
|
2374
|
+
};
|
|
2375
|
+
return trimObject(value);
|
|
2376
|
+
};
|
|
2377
|
+
const generateRestriction = (restriction) => {
|
|
2378
|
+
if (!isObject(restriction)) return;
|
|
2379
|
+
const value = {
|
|
2380
|
+
"#text": generateCdataString(restriction.value),
|
|
2381
|
+
"@relationship": generatePlainString(restriction.relationship),
|
|
2382
|
+
"@type": generatePlainString(restriction.type)
|
|
2383
|
+
};
|
|
2384
|
+
return trimObject(value);
|
|
2385
|
+
};
|
|
2386
|
+
const generateStarRating = (starRating) => {
|
|
2387
|
+
if (!isObject(starRating)) return;
|
|
2388
|
+
const value = {
|
|
2389
|
+
"@average": generateNumber(starRating.average),
|
|
2390
|
+
"@count": generateNumber(starRating.count),
|
|
2391
|
+
"@min": generateNumber(starRating.min),
|
|
2392
|
+
"@max": generateNumber(starRating.max)
|
|
2393
|
+
};
|
|
2394
|
+
return trimObject(value);
|
|
2395
|
+
};
|
|
2396
|
+
const generateStatistics = (statistics) => {
|
|
2397
|
+
if (!isObject(statistics)) return;
|
|
2398
|
+
const value = {
|
|
2399
|
+
"@views": generateNumber(statistics.views),
|
|
2400
|
+
"@favorites": generateNumber(statistics.favorites)
|
|
2401
|
+
};
|
|
2402
|
+
return trimObject(value);
|
|
2403
|
+
};
|
|
2404
|
+
const generateTag = (tag) => {
|
|
2405
|
+
if (!isObject(tag)) return;
|
|
2406
|
+
const name = generatePlainString(tag.name);
|
|
2407
|
+
if (!name) return;
|
|
2408
|
+
const weight = generateNumber(tag.weight) ?? 1;
|
|
2409
|
+
return `${name}:${weight}`;
|
|
2410
|
+
};
|
|
2411
|
+
const generateCommunity = (community) => {
|
|
2412
|
+
if (!isObject(community)) return;
|
|
2413
|
+
const value = {
|
|
2414
|
+
"media:starRating": generateStarRating(community.starRating),
|
|
2415
|
+
"media:statistics": generateStatistics(community.statistics),
|
|
2416
|
+
"media:tags": generateCsvOf(community.tags, generateTag)
|
|
2417
|
+
};
|
|
2418
|
+
return trimObject(value);
|
|
2419
|
+
};
|
|
2420
|
+
const generateComments = (comments) => {
|
|
2421
|
+
const value = { "media:comment": trimArray(comments, generatePlainString) };
|
|
2422
|
+
return trimObject(value);
|
|
2423
|
+
};
|
|
2424
|
+
const generateResponses = (responses) => {
|
|
2425
|
+
const value = { "media:response": trimArray(responses, generatePlainString) };
|
|
2426
|
+
return trimObject(value);
|
|
2427
|
+
};
|
|
2428
|
+
const generateBackLinks = (backLinks) => {
|
|
2429
|
+
const value = { "media:backLink": trimArray(backLinks, generatePlainString) };
|
|
2430
|
+
return trimObject(value);
|
|
2431
|
+
};
|
|
2432
|
+
const generateScenes = (scenes) => {
|
|
2433
|
+
const value = { "media:scene": trimArray(scenes, generateScene) };
|
|
2434
|
+
return trimObject(value);
|
|
2435
|
+
};
|
|
2436
|
+
const generateParam = (param) => {
|
|
2437
|
+
if (!isObject(param)) return;
|
|
2438
|
+
const value = {
|
|
2439
|
+
"#text": generateCdataString(param.value),
|
|
2440
|
+
"@name": generatePlainString(param.name)
|
|
2441
|
+
};
|
|
2442
|
+
return trimObject(value);
|
|
2443
|
+
};
|
|
2444
|
+
const generateEmbed = (embed) => {
|
|
2445
|
+
if (!isObject(embed)) return;
|
|
2446
|
+
const value = {
|
|
2447
|
+
"@url": generatePlainString(embed.url),
|
|
2448
|
+
"@width": generateNumber(embed.width),
|
|
2449
|
+
"@height": generateNumber(embed.height),
|
|
2450
|
+
"media:param": trimArray(embed.params, generateParam)
|
|
2451
|
+
};
|
|
2452
|
+
return trimObject(value);
|
|
2453
|
+
};
|
|
2454
|
+
const generateStatus = (status) => {
|
|
2455
|
+
if (!isObject(status)) return;
|
|
2456
|
+
const value = {
|
|
2457
|
+
"@state": generatePlainString(status.state),
|
|
2458
|
+
"@reason": generatePlainString(status.reason)
|
|
2459
|
+
};
|
|
2460
|
+
return trimObject(value);
|
|
2461
|
+
};
|
|
2462
|
+
const generatePrice = (price) => {
|
|
2463
|
+
if (!isObject(price)) return;
|
|
2464
|
+
const value = {
|
|
2465
|
+
"@type": generatePlainString(price.type),
|
|
2466
|
+
"@info": generatePlainString(price.info),
|
|
2467
|
+
"@price": generateNumber(price.price),
|
|
2468
|
+
"@currency": generatePlainString(price.currency)
|
|
2469
|
+
};
|
|
2470
|
+
return trimObject(value);
|
|
2471
|
+
};
|
|
2472
|
+
const generateLicense$1 = (license) => {
|
|
2473
|
+
if (!isObject(license)) return;
|
|
2474
|
+
const value = {
|
|
2475
|
+
"#text": generateCdataString(license.name),
|
|
2476
|
+
"@type": generatePlainString(license.type),
|
|
2477
|
+
"@href": generatePlainString(license.href)
|
|
2478
|
+
};
|
|
2479
|
+
return trimObject(value);
|
|
2480
|
+
};
|
|
2481
|
+
const generateSubTitle = (subTitle) => {
|
|
2482
|
+
if (!isObject(subTitle)) return;
|
|
2483
|
+
const value = {
|
|
2484
|
+
"@type": generatePlainString(subTitle.type),
|
|
2485
|
+
"@lang": generatePlainString(subTitle.lang),
|
|
2486
|
+
"@href": generatePlainString(subTitle.href)
|
|
2487
|
+
};
|
|
2488
|
+
return trimObject(value);
|
|
2489
|
+
};
|
|
2490
|
+
const generatePeerLink = (peerLink) => {
|
|
2491
|
+
if (!isObject(peerLink)) return;
|
|
2492
|
+
const value = {
|
|
2493
|
+
"@type": generatePlainString(peerLink.type),
|
|
2494
|
+
"@href": generatePlainString(peerLink.href)
|
|
2495
|
+
};
|
|
2496
|
+
return trimObject(value);
|
|
2497
|
+
};
|
|
2498
|
+
const generateRights = (rights) => {
|
|
2499
|
+
if (!isObject(rights)) return;
|
|
2500
|
+
const value = { "@status": generatePlainString(rights.status) };
|
|
2501
|
+
return trimObject(value);
|
|
2502
|
+
};
|
|
2503
|
+
const generateScene = (scene) => {
|
|
2504
|
+
if (!isObject(scene)) return;
|
|
2505
|
+
const value = {
|
|
2506
|
+
sceneTitle: generateCdataString(scene.title),
|
|
2507
|
+
sceneDescription: generateCdataString(scene.description),
|
|
2508
|
+
sceneStartTime: generateCdataString(scene.startTime),
|
|
2509
|
+
sceneEndTime: generateCdataString(scene.endTime)
|
|
2510
|
+
};
|
|
2511
|
+
return trimObject(value);
|
|
2512
|
+
};
|
|
2513
|
+
const generateLocation$1 = (location) => {
|
|
2514
|
+
if (!isObject(location)) return;
|
|
2515
|
+
const value = {
|
|
2516
|
+
"#text": generateCdataString(location.description),
|
|
2517
|
+
"@start": generatePlainString(location.start),
|
|
2518
|
+
"@end": generatePlainString(location.end),
|
|
2519
|
+
"@lat": generateNumber(location.lat),
|
|
2520
|
+
"@lng": generateNumber(location.lng)
|
|
2521
|
+
};
|
|
2522
|
+
return trimObject(value);
|
|
2523
|
+
};
|
|
2524
|
+
const generateCommonElements = (elements) => {
|
|
2525
|
+
if (!isObject(elements)) return;
|
|
2526
|
+
const value = {
|
|
2527
|
+
"media:rating": trimArray(elements.ratings, generateRating),
|
|
2528
|
+
"media:title": generateTitleOrDescription(elements.title),
|
|
2529
|
+
"media:description": generateTitleOrDescription(elements.description),
|
|
2530
|
+
"media:keywords": generateCsvOf(elements.keywords, generatePlainString),
|
|
2531
|
+
"media:thumbnail": trimArray(elements.thumbnails, generateThumbnail),
|
|
2532
|
+
"media:category": trimArray(elements.categories, generateCategory$2),
|
|
2533
|
+
"media:hash": trimArray(elements.hashes, generateHash),
|
|
2534
|
+
"media:player": generatePlayer(elements.player),
|
|
2535
|
+
"media:credit": trimArray(elements.credits, generateCredit),
|
|
2536
|
+
"media:copyright": generateCopyright(elements.copyright),
|
|
2537
|
+
"media:text": trimArray(elements.texts, generateText$1),
|
|
2538
|
+
"media:restriction": trimArray(elements.restrictions, generateRestriction),
|
|
2539
|
+
"media:community": generateCommunity(elements.community),
|
|
2540
|
+
"media:comments": generateComments(elements.comments),
|
|
2541
|
+
"media:embed": generateEmbed(elements.embed),
|
|
2542
|
+
"media:responses": generateResponses(elements.responses),
|
|
2543
|
+
"media:backLinks": generateBackLinks(elements.backLinks),
|
|
2544
|
+
"media:status": generateStatus(elements.status),
|
|
2545
|
+
"media:price": trimArray(elements.prices, generatePrice),
|
|
2546
|
+
"media:license": trimArray(elements.licenses, generateLicense$1),
|
|
2547
|
+
"media:subTitle": trimArray(elements.subTitles, generateSubTitle),
|
|
2548
|
+
"media:peerLink": trimArray(elements.peerLinks, generatePeerLink),
|
|
2549
|
+
"media:location": trimArray(elements.locations, generateLocation$1),
|
|
2550
|
+
"media:rights": generateRights(elements.rights),
|
|
2551
|
+
"media:scenes": generateScenes(elements.scenes)
|
|
2552
|
+
};
|
|
2553
|
+
return trimObject(value);
|
|
2554
|
+
};
|
|
2555
|
+
const generateContent = (content) => {
|
|
2556
|
+
if (!isObject(content)) return;
|
|
2557
|
+
const value = {
|
|
2558
|
+
"@url": generatePlainString(content.url),
|
|
2559
|
+
"@fileSize": generateNumber(content.fileSize),
|
|
2560
|
+
"@type": generatePlainString(content.type),
|
|
2561
|
+
"@medium": generatePlainString(content.medium),
|
|
2562
|
+
"@isDefault": generateYesNoBoolean(content.isDefault),
|
|
2563
|
+
"@expression": generatePlainString(content.expression),
|
|
2564
|
+
"@bitrate": generateNumber(content.bitrate),
|
|
2565
|
+
"@framerate": generateNumber(content.framerate),
|
|
2566
|
+
"@samplingrate": generateNumber(content.samplingrate),
|
|
2567
|
+
"@channels": generateNumber(content.channels),
|
|
2568
|
+
"@duration": generateNumber(content.duration),
|
|
2569
|
+
"@height": generateNumber(content.height),
|
|
2570
|
+
"@width": generateNumber(content.width),
|
|
2571
|
+
"@lang": generatePlainString(content.lang),
|
|
2572
|
+
...generateCommonElements(content)
|
|
2573
|
+
};
|
|
2574
|
+
return trimObject(value);
|
|
2575
|
+
};
|
|
2576
|
+
const generateGroup = (group) => {
|
|
2577
|
+
if (!isObject(group)) return;
|
|
2578
|
+
const value = {
|
|
2579
|
+
"media:content": trimArray(group.contents, generateContent),
|
|
2580
|
+
...generateCommonElements(group)
|
|
2581
|
+
};
|
|
2582
|
+
return trimObject(value);
|
|
2583
|
+
};
|
|
2584
|
+
const generateItemOrFeed$3 = (itemOrFeed) => {
|
|
2585
|
+
if (!isObject(itemOrFeed)) return;
|
|
2586
|
+
const value = {
|
|
2587
|
+
"media:group": generateGroup(itemOrFeed.group),
|
|
2588
|
+
"media:content": trimArray(itemOrFeed.contents, generateContent),
|
|
2589
|
+
...generateCommonElements(itemOrFeed)
|
|
2590
|
+
};
|
|
2591
|
+
return trimObject(value);
|
|
2592
|
+
};
|
|
2593
|
+
|
|
2594
|
+
//#endregion
|
|
2595
|
+
//#region src/namespaces/psc/generate/utils.ts
|
|
2596
|
+
const generateChapter = (chapter) => {
|
|
2597
|
+
if (!isObject(chapter)) return;
|
|
2598
|
+
const value = {
|
|
2599
|
+
"@start": generatePlainString(chapter.start),
|
|
2600
|
+
"@title": generatePlainString(chapter.title),
|
|
2601
|
+
"@href": generatePlainString(chapter.href),
|
|
2602
|
+
"@image": generatePlainString(chapter.image)
|
|
2603
|
+
};
|
|
2604
|
+
return trimObject(value);
|
|
2605
|
+
};
|
|
2606
|
+
const generateChapters$1 = (chapters) => {
|
|
2607
|
+
const value = { "psc:chapter": trimArray(chapters, generateChapter) };
|
|
2608
|
+
return trimObject(value);
|
|
2609
|
+
};
|
|
2610
|
+
const generateItem$3 = (item) => {
|
|
2611
|
+
if (!isObject(item)) return;
|
|
2612
|
+
return trimObject({ "psc:chapters": generateChapters$1(item.chapters) });
|
|
2613
|
+
};
|
|
2614
|
+
|
|
2615
|
+
//#endregion
|
|
2616
|
+
//#region src/namespaces/slash/generate/utils.ts
|
|
2617
|
+
const generateItem$4 = (item) => {
|
|
2618
|
+
if (!isObject(item)) return;
|
|
2619
|
+
const value = {
|
|
2620
|
+
"slash:section": generateCdataString(item.section),
|
|
2621
|
+
"slash:department": generateCdataString(item.department),
|
|
2622
|
+
"slash:comments": generateNumber(item.comments),
|
|
2623
|
+
"slash:hit_parade": generateCsvOf(item.hitParade, generateNumber)
|
|
2624
|
+
};
|
|
2625
|
+
return trimObject(value);
|
|
2626
|
+
};
|
|
2627
|
+
|
|
2628
|
+
//#endregion
|
|
2629
|
+
//#region src/namespaces/sy/generate/utils.ts
|
|
2630
|
+
const generateFeed$5 = (feed) => {
|
|
2631
|
+
if (!isObject(feed)) return;
|
|
2632
|
+
const value = {
|
|
2633
|
+
"sy:updatePeriod": generateCdataString(feed.updatePeriod),
|
|
2634
|
+
"sy:updateFrequency": generateNumber(feed.updateFrequency),
|
|
2635
|
+
"sy:updateBase": generateRfc3339Date(feed.updateBase)
|
|
2636
|
+
};
|
|
2637
|
+
return trimObject(value);
|
|
2638
|
+
};
|
|
2639
|
+
|
|
2640
|
+
//#endregion
|
|
2641
|
+
//#region src/namespaces/thr/generate/utils.ts
|
|
2642
|
+
const generateInReplyTo = (inReplyTo) => {
|
|
2643
|
+
if (!isObject(inReplyTo)) return;
|
|
2644
|
+
const value = {
|
|
2645
|
+
"@ref": generatePlainString(inReplyTo.ref),
|
|
2646
|
+
"@href": generatePlainString(inReplyTo.href),
|
|
2647
|
+
"@type": generatePlainString(inReplyTo.type),
|
|
2648
|
+
"@source": generatePlainString(inReplyTo.source)
|
|
2649
|
+
};
|
|
2650
|
+
return trimObject(value);
|
|
2651
|
+
};
|
|
2652
|
+
const generateLink = (link) => {
|
|
2653
|
+
if (!isObject(link)) return;
|
|
2654
|
+
const value = {
|
|
2655
|
+
"@thr:count": generateNumber(link.count),
|
|
2656
|
+
"@thr:updated": generateRfc3339Date(link.updated)
|
|
2657
|
+
};
|
|
2658
|
+
return trimObject(value);
|
|
2659
|
+
};
|
|
2660
|
+
const generateItem$6 = (item) => {
|
|
2661
|
+
if (!isObject(item)) return;
|
|
2662
|
+
const value = {
|
|
2663
|
+
"thr:total": generateNumber(item.total),
|
|
2664
|
+
"thr:in-reply-to": trimArray(item.inReplyTos, generateInReplyTo)
|
|
2665
|
+
};
|
|
2666
|
+
return trimObject(value);
|
|
2667
|
+
};
|
|
2668
|
+
|
|
2669
|
+
//#endregion
|
|
2670
|
+
//#region src/namespaces/wfw/generate/utils.ts
|
|
2671
|
+
const generateItem$7 = (item) => {
|
|
2672
|
+
if (!isObject(item)) return;
|
|
2673
|
+
const value = {
|
|
2674
|
+
"wfw:comment": generateCdataString(item.comment),
|
|
2675
|
+
"wfw:commentRss": generateCdataString(item.commentRss)
|
|
2676
|
+
};
|
|
2677
|
+
return trimObject(value);
|
|
2678
|
+
};
|
|
2679
|
+
|
|
2680
|
+
//#endregion
|
|
2681
|
+
//#region src/namespaces/yt/generate/utils.ts
|
|
2682
|
+
const generateItem$10 = (item) => {
|
|
2683
|
+
if (!isObject(item)) return;
|
|
2684
|
+
const value = {
|
|
2685
|
+
"yt:videoId": generateCdataString(item.videoId),
|
|
2686
|
+
"yt:channelId": generateCdataString(item.channelId)
|
|
2687
|
+
};
|
|
2688
|
+
return trimObject(value);
|
|
2689
|
+
};
|
|
2690
|
+
const generateFeed$8 = (feed) => {
|
|
2691
|
+
if (!isObject(feed)) return;
|
|
2692
|
+
const value = {
|
|
2693
|
+
"yt:channelId": generateCdataString(feed.channelId),
|
|
2694
|
+
"yt:playlistId": generateCdataString(feed.playlistId)
|
|
2695
|
+
};
|
|
2696
|
+
return trimObject(value);
|
|
2697
|
+
};
|
|
2698
|
+
|
|
2699
|
+
//#endregion
|
|
2700
|
+
//#region src/feeds/atom/generate/utils.ts
|
|
2701
|
+
const createNamespaceSetter = (prefix) => {
|
|
2702
|
+
return (key) => prefix ? `${prefix}${key}` : key;
|
|
2703
|
+
};
|
|
2704
|
+
const generateText = (text) => {
|
|
2705
|
+
return generateCdataString(text);
|
|
2706
|
+
};
|
|
2707
|
+
const generateLink$1 = (link) => {
|
|
2708
|
+
if (!isObject(link)) return;
|
|
2709
|
+
const value = {
|
|
2710
|
+
"@href": generatePlainString(link.href),
|
|
2711
|
+
"@rel": generatePlainString(link.rel),
|
|
2712
|
+
"@type": generatePlainString(link.type),
|
|
2713
|
+
"@hreflang": generatePlainString(link.hreflang),
|
|
2714
|
+
"@title": generatePlainString(link.title),
|
|
2715
|
+
"@length": generateNumber(link.length),
|
|
2716
|
+
...generateLink(link.thr)
|
|
2717
|
+
};
|
|
2718
|
+
return trimObject(value);
|
|
2719
|
+
};
|
|
2720
|
+
const generatePerson$2 = (person, options) => {
|
|
2721
|
+
if (!isObject(person)) return;
|
|
2722
|
+
const key = createNamespaceSetter(options?.prefix);
|
|
2723
|
+
const value = {
|
|
2724
|
+
[key("name")]: generateCdataString(person.name),
|
|
2725
|
+
[key("uri")]: generateCdataString(person.uri),
|
|
2726
|
+
[key("email")]: generateCdataString(person.email)
|
|
2727
|
+
};
|
|
2728
|
+
return trimObject(value);
|
|
2729
|
+
};
|
|
2730
|
+
const generateCategory$1 = (category) => {
|
|
2731
|
+
if (!isObject(category)) return;
|
|
2732
|
+
const value = {
|
|
2733
|
+
"@term": generatePlainString(category.term),
|
|
2734
|
+
"@scheme": generatePlainString(category.scheme),
|
|
2735
|
+
"@label": generatePlainString(category.label)
|
|
2736
|
+
};
|
|
2737
|
+
return trimObject(value);
|
|
2738
|
+
};
|
|
2739
|
+
const generateGenerator = (generator) => {
|
|
2740
|
+
if (!isObject(generator)) return;
|
|
2741
|
+
const value = {
|
|
2742
|
+
"#text": generateCdataString(generator.text),
|
|
2743
|
+
"@uri": generatePlainString(generator.uri),
|
|
2744
|
+
"@version": generatePlainString(generator.version)
|
|
2745
|
+
};
|
|
2746
|
+
return trimObject(value);
|
|
2747
|
+
};
|
|
2748
|
+
const generateSource$2 = (source, options) => {
|
|
2749
|
+
if (!isObject(source)) return;
|
|
2750
|
+
const key = createNamespaceSetter(options?.prefix);
|
|
2751
|
+
const value = {
|
|
2752
|
+
[key("author")]: trimArray(source.authors, (author) => generatePerson$2(author, options)),
|
|
2753
|
+
[key("category")]: trimArray(source.categories, (category) => generateCategory$1(category, options)),
|
|
2754
|
+
[key("contributor")]: trimArray(source.contributors, (contributor) => generatePerson$2(contributor, options)),
|
|
2755
|
+
[key("generator")]: generateGenerator(source.generator),
|
|
2756
|
+
[key("icon")]: generateCdataString(source.icon),
|
|
2757
|
+
[key("id")]: generateCdataString(source.id),
|
|
2758
|
+
[key("link")]: trimArray(source.links, (link) => generateLink$1(link, options)),
|
|
2759
|
+
[key("logo")]: generateCdataString(source.logo),
|
|
2760
|
+
[key("rights")]: generateText(source.rights),
|
|
2761
|
+
[key("subtitle")]: generateText(source.subtitle),
|
|
2762
|
+
[key("title")]: generateText(source.title),
|
|
2763
|
+
[key("updated")]: generateRfc3339Date(source.updated)
|
|
2764
|
+
};
|
|
2765
|
+
return trimObject(value);
|
|
2766
|
+
};
|
|
2767
|
+
const generateEntry$1 = (entry, options) => {
|
|
2768
|
+
if (!isObject(entry)) return;
|
|
2769
|
+
const key = createNamespaceSetter(options?.prefix);
|
|
2770
|
+
const value = {
|
|
2771
|
+
[key("author")]: trimArray(entry.authors, generatePerson$2),
|
|
2772
|
+
[key("category")]: trimArray(entry.categories, generateCategory$1),
|
|
2773
|
+
[key("content")]: generateText(entry.content),
|
|
2774
|
+
[key("contributor")]: trimArray(entry.contributors, (contributor) => generatePerson$2(contributor, options)),
|
|
2775
|
+
[key("id")]: generateCdataString(entry.id),
|
|
2776
|
+
[key("link")]: trimArray(entry.links, (link) => generateLink$1(link, options)),
|
|
2777
|
+
[key("published")]: generateRfc3339Date(entry.published),
|
|
2778
|
+
[key("rights")]: generateText(entry.rights),
|
|
2779
|
+
[key("source")]: generateSource$2(entry.source),
|
|
2780
|
+
[key("summary")]: generateText(entry.summary),
|
|
2781
|
+
[key("title")]: generateText(entry.title),
|
|
2782
|
+
[key("updated")]: generateRfc3339Date(entry.updated)
|
|
2783
|
+
};
|
|
2784
|
+
const trimmedValue = trimObject(value);
|
|
2785
|
+
if (!trimmedValue) return;
|
|
2786
|
+
if (options?.asNamespace) return trimmedValue;
|
|
2787
|
+
return {
|
|
2788
|
+
...trimmedValue,
|
|
2789
|
+
...generateItemOrFeed(entry.dc),
|
|
2790
|
+
...generateItem$4(entry.slash),
|
|
2791
|
+
...generateItem$1(entry.itunes),
|
|
2792
|
+
...generateItem$3(entry.psc),
|
|
2793
|
+
...generateItemOrFeed$3(entry.media),
|
|
2794
|
+
...generateItemOrFeed$2(entry.georss),
|
|
2795
|
+
...generateItem$6(entry.thr),
|
|
2796
|
+
...generateItemOrFeed$1(entry.dcterms),
|
|
2797
|
+
...generateItem$7(entry.wfw),
|
|
2798
|
+
...generateItem$10(entry.yt)
|
|
2799
|
+
};
|
|
2800
|
+
};
|
|
2801
|
+
const generateFeed$6 = (feed, options) => {
|
|
2802
|
+
if (!isObject(feed)) return;
|
|
2803
|
+
const key = createNamespaceSetter(options?.prefix);
|
|
2804
|
+
const feedValue = {
|
|
2805
|
+
[key("author")]: trimArray(feed.authors, (author) => generatePerson$2(author, options)),
|
|
2806
|
+
[key("category")]: trimArray(feed.categories, (category) => generateCategory$1(category, options)),
|
|
2807
|
+
[key("contributor")]: trimArray(feed.contributors, (contributor) => generatePerson$2(contributor, options)),
|
|
2808
|
+
[key("generator")]: generateGenerator(feed.generator),
|
|
2809
|
+
[key("icon")]: generateCdataString(feed.icon),
|
|
2810
|
+
[key("id")]: generateCdataString(feed.id),
|
|
2811
|
+
[key("link")]: trimArray(feed.links, (link) => generateLink$1(link, options)),
|
|
2812
|
+
[key("logo")]: generateCdataString(feed.logo),
|
|
2813
|
+
[key("rights")]: generateText(feed.rights),
|
|
2814
|
+
[key("subtitle")]: generateText(feed.subtitle),
|
|
2815
|
+
[key("title")]: generateText(feed.title),
|
|
2816
|
+
[key("updated")]: generateRfc3339Date(feed.updated)
|
|
2817
|
+
};
|
|
2818
|
+
const valueFeed = trimObject(feedValue);
|
|
2819
|
+
const entriesValue = { [key("entry")]: trimArray(feed.entries, (entry) => generateEntry$1(entry, options)) };
|
|
2820
|
+
const valueEntries = trimObject(entriesValue);
|
|
2821
|
+
if (!valueFeed && !valueEntries) return;
|
|
2822
|
+
if (options?.asNamespace) return { feed: {
|
|
2823
|
+
...valueFeed,
|
|
2824
|
+
...valueEntries
|
|
2825
|
+
} };
|
|
2826
|
+
const valueFull = {
|
|
2827
|
+
...valueFeed,
|
|
2828
|
+
...generateItemOrFeed(feed.dc),
|
|
2829
|
+
...generateFeed$5(feed.sy),
|
|
2830
|
+
...generateFeed$2(feed.itunes),
|
|
2831
|
+
...generateItemOrFeed$3(feed.media),
|
|
2832
|
+
...generateItemOrFeed$2(feed.georss),
|
|
2833
|
+
...generateItemOrFeed$1(feed.dcterms),
|
|
2834
|
+
...generateFeed$8(feed.yt),
|
|
2835
|
+
...valueEntries
|
|
2836
|
+
};
|
|
2837
|
+
return { feed: {
|
|
2838
|
+
"@xmlns": "http://www.w3.org/2005/Atom",
|
|
2839
|
+
...generateNamespaceAttrs({ value: valueFull }, namespaceUrls),
|
|
2840
|
+
...valueFull
|
|
2841
|
+
} };
|
|
2842
|
+
};
|
|
2843
|
+
|
|
2844
|
+
//#endregion
|
|
2845
|
+
//#region src/feeds/atom/generate/index.ts
|
|
2846
|
+
const generate = (value, options) => {
|
|
2847
|
+
const generated = generateFeed$6(value);
|
|
2848
|
+
if (!generated) throw new Error("Invalid input Atom");
|
|
2849
|
+
return generateXml(builder$2, generated, options);
|
|
2850
|
+
};
|
|
2851
|
+
|
|
2852
|
+
//#endregion
|
|
2853
|
+
//#region src/feeds/json/generate/utils.ts
|
|
2854
|
+
const generateItem$9 = (item) => {
|
|
2855
|
+
const value = {
|
|
2856
|
+
...item,
|
|
2857
|
+
date_published: generateRfc3339Date(item?.date_published),
|
|
2858
|
+
date_modified: generateRfc3339Date(item?.date_modified)
|
|
2859
|
+
};
|
|
2860
|
+
return trimObject(value);
|
|
2861
|
+
};
|
|
2862
|
+
const generateFeed$7 = (feed) => {
|
|
2863
|
+
const value = {
|
|
2864
|
+
version: "https://jsonfeed.org/version/1.1",
|
|
2865
|
+
...feed,
|
|
2866
|
+
items: trimArray(feed?.items, generateItem$9)
|
|
2867
|
+
};
|
|
2868
|
+
return trimObject(value);
|
|
2869
|
+
};
|
|
2870
|
+
|
|
2871
|
+
//#endregion
|
|
2872
|
+
//#region src/feeds/json/generate/index.ts
|
|
2873
|
+
const generate$1 = (value) => {
|
|
2874
|
+
return generateFeed$7(value);
|
|
2875
|
+
};
|
|
2876
|
+
|
|
2877
|
+
//#endregion
|
|
2878
|
+
//#region src/feeds/rss/generate/config.ts
|
|
2879
|
+
const builder$1 = new XMLBuilder({ ...builderConfig });
|
|
2880
|
+
|
|
2881
|
+
//#endregion
|
|
2882
|
+
//#region src/namespaces/atom/generate/utils.ts
|
|
2883
|
+
const generateEntry = (entry) => {
|
|
2884
|
+
return generateEntry$1(entry, {
|
|
2885
|
+
prefix: "atom:",
|
|
2886
|
+
asNamespace: true
|
|
2887
|
+
});
|
|
2888
|
+
};
|
|
2889
|
+
const generateFeed$1 = (feed) => {
|
|
2890
|
+
return generateFeed$6(feed, {
|
|
2891
|
+
prefix: "atom:",
|
|
2892
|
+
asNamespace: true
|
|
2893
|
+
})?.feed;
|
|
2894
|
+
};
|
|
2895
|
+
|
|
2896
|
+
//#endregion
|
|
2897
|
+
//#region src/namespaces/content/generate/utils.ts
|
|
2898
|
+
const generateItem = (item) => {
|
|
2899
|
+
if (!isObject(item)) return;
|
|
2900
|
+
const value = { "content:encoded": generateCdataString(item?.encoded) };
|
|
2901
|
+
return trimObject(value);
|
|
2902
|
+
};
|
|
2903
|
+
|
|
2904
|
+
//#endregion
|
|
2905
|
+
//#region src/namespaces/podcast/generate/utils.ts
|
|
2906
|
+
const generateBaseItem = (baseItem) => {
|
|
2907
|
+
if (!isObject(baseItem)) return;
|
|
2908
|
+
const value = {
|
|
2909
|
+
"podcast:transcript": trimArray(baseItem.transcripts, generateTranscript),
|
|
2910
|
+
"podcast:chapters": generateChapters(baseItem.chapters),
|
|
2911
|
+
"podcast:soundbite": trimArray(baseItem.soundbites, generateSoundbite),
|
|
2912
|
+
"podcast:person": trimArray(baseItem.persons, generatePerson$1),
|
|
2913
|
+
"podcast:location": generateLocation(baseItem.location),
|
|
2914
|
+
"podcast:season": generateSeason(baseItem.season),
|
|
2915
|
+
"podcast:episode": generateEpisode(baseItem.episode),
|
|
2916
|
+
"podcast:license": generateLicense(baseItem.license),
|
|
2917
|
+
"podcast:alternateEnclosure": trimArray(baseItem.alternateEnclosures, generateAlternateEnclosure),
|
|
2918
|
+
"podcast:value": generateValue(baseItem.value),
|
|
2919
|
+
"podcast:images": generateImages(baseItem.images),
|
|
2920
|
+
"podcast:socialInteract": trimArray(baseItem.socialInteracts, generateSocialInteract),
|
|
2921
|
+
"podcast:txt": trimArray(baseItem.txts, generateTxt)
|
|
2922
|
+
};
|
|
2923
|
+
return trimObject(value);
|
|
2924
|
+
};
|
|
2925
|
+
const generateTranscript = (transcript) => {
|
|
2926
|
+
if (!isObject(transcript)) return;
|
|
2927
|
+
const value = {
|
|
2928
|
+
"@url": generatePlainString(transcript.url),
|
|
2929
|
+
"@type": generatePlainString(transcript.type),
|
|
2930
|
+
"@language": generatePlainString(transcript.language),
|
|
2931
|
+
"@rel": generatePlainString(transcript.rel)
|
|
2932
|
+
};
|
|
2933
|
+
return trimObject(value);
|
|
2934
|
+
};
|
|
2935
|
+
const generateLocked = (locked) => {
|
|
2936
|
+
if (!isObject(locked)) return;
|
|
2937
|
+
const value = {
|
|
2938
|
+
"#text": generateYesNoBoolean(locked.value),
|
|
2939
|
+
"@owner": generatePlainString(locked.owner)
|
|
2940
|
+
};
|
|
2941
|
+
return trimObject(value);
|
|
2942
|
+
};
|
|
2943
|
+
const generateFunding = (funding) => {
|
|
2944
|
+
if (!isObject(funding)) return;
|
|
2945
|
+
const value = {
|
|
2946
|
+
"#text": generateCdataString(funding.display),
|
|
2947
|
+
"@url": generatePlainString(funding.url)
|
|
2948
|
+
};
|
|
2949
|
+
return trimObject(value);
|
|
2950
|
+
};
|
|
2951
|
+
const generateChapters = (chapters) => {
|
|
2952
|
+
if (!isObject(chapters)) return;
|
|
2953
|
+
const value = {
|
|
2954
|
+
"@url": generatePlainString(chapters.url),
|
|
2955
|
+
"@type": generatePlainString(chapters.type)
|
|
2956
|
+
};
|
|
2957
|
+
return trimObject(value);
|
|
2958
|
+
};
|
|
2959
|
+
const generateSoundbite = (soundbite) => {
|
|
2960
|
+
if (!isObject(soundbite)) return;
|
|
2961
|
+
const value = {
|
|
2962
|
+
"#text": generateCdataString(soundbite.display),
|
|
2963
|
+
"@startTime": generateNumber(soundbite.startTime),
|
|
2964
|
+
"@duration": generateNumber(soundbite.duration)
|
|
2965
|
+
};
|
|
2966
|
+
return trimObject(value);
|
|
2967
|
+
};
|
|
2968
|
+
const generatePerson$1 = (person) => {
|
|
2969
|
+
if (!isObject(person)) return;
|
|
2970
|
+
const value = {
|
|
2971
|
+
"#text": generateCdataString(person.display),
|
|
2972
|
+
"@role": generatePlainString(person.role),
|
|
2973
|
+
"@group": generatePlainString(person.group),
|
|
2974
|
+
"@img": generatePlainString(person.img),
|
|
2975
|
+
"@href": generatePlainString(person.href)
|
|
2976
|
+
};
|
|
2977
|
+
return trimObject(value);
|
|
2978
|
+
};
|
|
2979
|
+
const generateLocation = (location) => {
|
|
2980
|
+
if (!isObject(location)) return;
|
|
2981
|
+
const value = {
|
|
2982
|
+
"#text": generateCdataString(location.display),
|
|
2983
|
+
"@geo": generatePlainString(location.geo),
|
|
2984
|
+
"@osm": generatePlainString(location.osm)
|
|
2985
|
+
};
|
|
2986
|
+
return trimObject(value);
|
|
2987
|
+
};
|
|
2988
|
+
const generateSeason = (season) => {
|
|
2989
|
+
if (!isObject(season)) return;
|
|
2990
|
+
const value = {
|
|
2991
|
+
"#text": generateNumber(season.number),
|
|
2992
|
+
"@name": generatePlainString(season.name)
|
|
2993
|
+
};
|
|
2994
|
+
return trimObject(value);
|
|
2995
|
+
};
|
|
2996
|
+
const generateEpisode = (episode) => {
|
|
2997
|
+
if (!isObject(episode)) return;
|
|
2998
|
+
const value = {
|
|
2999
|
+
"#text": generateNumber(episode.number),
|
|
3000
|
+
"@display": generatePlainString(episode.display)
|
|
3001
|
+
};
|
|
3002
|
+
return trimObject(value);
|
|
3003
|
+
};
|
|
3004
|
+
const generateTrailer = (trailer) => {
|
|
3005
|
+
if (!isObject(trailer)) return;
|
|
3006
|
+
const value = {
|
|
3007
|
+
"#text": generateCdataString(trailer.display),
|
|
3008
|
+
"@url": generatePlainString(trailer.url),
|
|
3009
|
+
"@pubdate": generateRfc822Date(trailer.pubDate),
|
|
3010
|
+
"@length": generateNumber(trailer.length),
|
|
3011
|
+
"@type": generatePlainString(trailer.type),
|
|
3012
|
+
"@season": generateNumber(trailer.season)
|
|
3013
|
+
};
|
|
3014
|
+
return trimObject(value);
|
|
3015
|
+
};
|
|
3016
|
+
const generateLicense = (license) => {
|
|
3017
|
+
if (!isObject(license)) return;
|
|
3018
|
+
const value = {
|
|
3019
|
+
"#text": generateCdataString(license.display),
|
|
3020
|
+
"@url": generatePlainString(license.url)
|
|
3021
|
+
};
|
|
3022
|
+
return trimObject(value);
|
|
3023
|
+
};
|
|
3024
|
+
const generateSource$1 = (source) => {
|
|
3025
|
+
if (!isObject(source)) return;
|
|
3026
|
+
const value = {
|
|
3027
|
+
"@uri": generatePlainString(source.uri),
|
|
3028
|
+
"@contentType": generatePlainString(source.contentType)
|
|
3029
|
+
};
|
|
3030
|
+
return trimObject(value);
|
|
3031
|
+
};
|
|
3032
|
+
const generateIntegrity = (integrity) => {
|
|
3033
|
+
if (!isObject(integrity)) return;
|
|
3034
|
+
const value = {
|
|
3035
|
+
"@type": generatePlainString(integrity.type),
|
|
3036
|
+
"@value": generatePlainString(integrity.value)
|
|
3037
|
+
};
|
|
3038
|
+
return trimObject(value);
|
|
3039
|
+
};
|
|
3040
|
+
const generateAlternateEnclosure = (alternateEnclosure) => {
|
|
3041
|
+
if (!isObject(alternateEnclosure)) return;
|
|
3042
|
+
const value = {
|
|
3043
|
+
"@type": generatePlainString(alternateEnclosure.type),
|
|
3044
|
+
"@length": generateNumber(alternateEnclosure.length),
|
|
3045
|
+
"@bitrate": generateNumber(alternateEnclosure.bitrate),
|
|
3046
|
+
"@height": generateNumber(alternateEnclosure.height),
|
|
3047
|
+
"@lang": generatePlainString(alternateEnclosure.lang),
|
|
3048
|
+
"@title": generatePlainString(alternateEnclosure.title),
|
|
3049
|
+
"@rel": generatePlainString(alternateEnclosure.rel),
|
|
3050
|
+
"@codecs": generatePlainString(alternateEnclosure.codecs),
|
|
3051
|
+
"@default": generateBoolean(alternateEnclosure.default),
|
|
3052
|
+
"podcast:source": trimArray(alternateEnclosure.sources, generateSource$1),
|
|
3053
|
+
"podcast:integrity": generateIntegrity(alternateEnclosure.integrity)
|
|
3054
|
+
};
|
|
3055
|
+
return trimObject(value);
|
|
3056
|
+
};
|
|
3057
|
+
const generateValueRecipient = (valueRecipient) => {
|
|
3058
|
+
if (!isObject(valueRecipient)) return;
|
|
3059
|
+
const value = {
|
|
3060
|
+
"@name": generatePlainString(valueRecipient.name),
|
|
3061
|
+
"@customKey": generatePlainString(valueRecipient.customKey),
|
|
3062
|
+
"@customValue": generatePlainString(valueRecipient.customValue),
|
|
3063
|
+
"@type": generatePlainString(valueRecipient.type),
|
|
3064
|
+
"@address": generatePlainString(valueRecipient.address),
|
|
3065
|
+
"@split": generateNumber(valueRecipient.split),
|
|
3066
|
+
"@fee": generateBoolean(valueRecipient.fee)
|
|
3067
|
+
};
|
|
3068
|
+
return trimObject(value);
|
|
3069
|
+
};
|
|
3070
|
+
const generateValueTimeSplit = (valueTimeSplit) => {
|
|
3071
|
+
if (!isObject(valueTimeSplit)) return;
|
|
3072
|
+
const value = {
|
|
3073
|
+
"@startTime": generateNumber(valueTimeSplit.startTime),
|
|
3074
|
+
"@duration": generateNumber(valueTimeSplit.duration),
|
|
3075
|
+
"@remoteStartTime": generateNumber(valueTimeSplit.remoteStartTime),
|
|
3076
|
+
"@remotePercentage": generateNumber(valueTimeSplit.remotePercentage),
|
|
3077
|
+
"podcast:remoteItem": generateRemoteItem(valueTimeSplit.remoteItem),
|
|
3078
|
+
"podcast:valueRecipient": trimArray(valueTimeSplit.valueRecipients, generateValueRecipient)
|
|
3079
|
+
};
|
|
3080
|
+
return trimObject(value);
|
|
3081
|
+
};
|
|
3082
|
+
const generateValue = (value) => {
|
|
3083
|
+
if (!isObject(value)) return;
|
|
3084
|
+
const valueOut = {
|
|
3085
|
+
"@type": generatePlainString(value.type),
|
|
3086
|
+
"@method": generatePlainString(value.method),
|
|
3087
|
+
"@suggested": generateNumber(value.suggested),
|
|
3088
|
+
"podcast:valueRecipient": trimArray(value.valueRecipients, generateValueRecipient),
|
|
3089
|
+
"podcast:valueTimeSplit": trimArray(value.valueTimeSplits, generateValueTimeSplit)
|
|
3090
|
+
};
|
|
3091
|
+
return trimObject(valueOut);
|
|
3092
|
+
};
|
|
3093
|
+
const generateImages = (images) => {
|
|
3094
|
+
if (!isObject(images)) return;
|
|
3095
|
+
const value = { "@srcset": generatePlainString(images.srcset) };
|
|
3096
|
+
return trimObject(value);
|
|
3097
|
+
};
|
|
3098
|
+
const generateContentLink = (contentLink) => {
|
|
3099
|
+
if (!isObject(contentLink)) return;
|
|
3100
|
+
const value = {
|
|
3101
|
+
"#text": generateCdataString(contentLink.display),
|
|
3102
|
+
"@href": generatePlainString(contentLink.href)
|
|
3103
|
+
};
|
|
3104
|
+
return trimObject(value);
|
|
3105
|
+
};
|
|
3106
|
+
const generateLiveItem = (liveItem) => {
|
|
3107
|
+
if (!isObject(liveItem)) return;
|
|
3108
|
+
const value = {
|
|
3109
|
+
...generateBaseItem(liveItem),
|
|
3110
|
+
"@status": generatePlainString(liveItem.status),
|
|
3111
|
+
"@start": generateRfc3339Date(liveItem.start),
|
|
3112
|
+
"@end": generateRfc3339Date(liveItem.end),
|
|
3113
|
+
"podcast:contentLink": trimArray(liveItem.contentLinks, generateContentLink)
|
|
3114
|
+
};
|
|
3115
|
+
return trimObject(value);
|
|
3116
|
+
};
|
|
3117
|
+
const generateSocialInteract = (socialInteract) => {
|
|
3118
|
+
if (!isObject(socialInteract)) return;
|
|
3119
|
+
const value = {
|
|
3120
|
+
"@uri": generatePlainString(socialInteract.uri),
|
|
3121
|
+
"@protocol": generatePlainString(socialInteract.protocol),
|
|
3122
|
+
"@accountId": generatePlainString(socialInteract.accountId),
|
|
3123
|
+
"@accountUrl": generatePlainString(socialInteract.accountUrl),
|
|
3124
|
+
"@priority": generateNumber(socialInteract.priority)
|
|
3125
|
+
};
|
|
3126
|
+
return trimObject(value);
|
|
3127
|
+
};
|
|
3128
|
+
const generateBlock = (block) => {
|
|
3129
|
+
if (!isObject(block)) return;
|
|
3130
|
+
const value = {
|
|
3131
|
+
"#text": generateYesNoBoolean(block.value),
|
|
3132
|
+
"@id": generatePlainString(block.id)
|
|
3133
|
+
};
|
|
3134
|
+
return trimObject(value);
|
|
3135
|
+
};
|
|
3136
|
+
const generateTxt = (txt) => {
|
|
3137
|
+
if (!isObject(txt)) return;
|
|
3138
|
+
const value = {
|
|
3139
|
+
"#text": generateCdataString(txt.display),
|
|
3140
|
+
"@purpose": generatePlainString(txt.purpose)
|
|
3141
|
+
};
|
|
3142
|
+
return trimObject(value);
|
|
3143
|
+
};
|
|
3144
|
+
const generateRemoteItem = (remoteItem) => {
|
|
3145
|
+
if (!isObject(remoteItem)) return;
|
|
3146
|
+
const value = {
|
|
3147
|
+
"@feedGuid": generatePlainString(remoteItem.feedGuid),
|
|
3148
|
+
"@feedUrl": generatePlainString(remoteItem.feedUrl),
|
|
3149
|
+
"@itemGuid": generatePlainString(remoteItem.itemGuid),
|
|
3150
|
+
"@medium": generatePlainString(remoteItem.medium)
|
|
3151
|
+
};
|
|
3152
|
+
return trimObject(value);
|
|
3153
|
+
};
|
|
3154
|
+
const generatePodroll = (podroll) => {
|
|
3155
|
+
if (!isObject(podroll)) return;
|
|
3156
|
+
const value = { "podcast:remoteItem": trimArray(podroll.remoteItems, generateRemoteItem) };
|
|
3157
|
+
return trimObject(value);
|
|
3158
|
+
};
|
|
3159
|
+
const generateUpdateFrequency = (updateFrequency) => {
|
|
3160
|
+
if (!isObject(updateFrequency)) return;
|
|
3161
|
+
const value = {
|
|
3162
|
+
"#text": generateCdataString(updateFrequency.display),
|
|
3163
|
+
"@complete": generateBoolean(updateFrequency.complete),
|
|
3164
|
+
"@dtstart": generateRfc3339Date(updateFrequency.dtstart),
|
|
3165
|
+
"@rrule": generatePlainString(updateFrequency.rrule)
|
|
3166
|
+
};
|
|
3167
|
+
return trimObject(value);
|
|
3168
|
+
};
|
|
3169
|
+
const generatePodping = (podping) => {
|
|
3170
|
+
if (!isObject(podping)) return;
|
|
3171
|
+
const value = { "@usesPodping": generateBoolean(podping.usesPodping) };
|
|
3172
|
+
return trimObject(value);
|
|
3173
|
+
};
|
|
3174
|
+
const generateItem$2 = (item) => {
|
|
3175
|
+
if (!isObject(item)) return;
|
|
3176
|
+
return generateBaseItem(item);
|
|
3177
|
+
};
|
|
3178
|
+
const generateFeed$3 = (feed) => {
|
|
3179
|
+
if (!isObject(feed)) return;
|
|
3180
|
+
const value = {
|
|
3181
|
+
"podcast:locked": generateLocked(feed.locked),
|
|
3182
|
+
"podcast:funding": trimArray(feed.fundings, generateFunding),
|
|
3183
|
+
"podcast:person": trimArray(feed.persons, generatePerson$1),
|
|
3184
|
+
"podcast:location": generateLocation(feed.location),
|
|
3185
|
+
"podcast:trailer": trimArray(feed.trailers, generateTrailer),
|
|
3186
|
+
"podcast:license": generateLicense(feed.license),
|
|
3187
|
+
"podcast:guid": generateCdataString(feed.guid),
|
|
3188
|
+
"podcast:value": generateValue(feed.value),
|
|
3189
|
+
"podcast:medium": generateCdataString(feed.medium),
|
|
3190
|
+
"podcast:images": generateImages(feed.images),
|
|
3191
|
+
"podcast:liveItem": trimArray(feed.liveItems, generateLiveItem),
|
|
3192
|
+
"podcast:block": trimArray(feed.blocks, generateBlock),
|
|
3193
|
+
"podcast:txt": trimArray(feed.txts, generateTxt),
|
|
3194
|
+
"podcast:remoteItem": trimArray(feed.remoteItems, generateRemoteItem),
|
|
3195
|
+
"podcast:podroll": generatePodroll(feed.podroll),
|
|
3196
|
+
"podcast:updateFrequency": generateUpdateFrequency(feed.updateFrequency),
|
|
3197
|
+
"podcast:podping": generatePodping(feed.podping)
|
|
3198
|
+
};
|
|
3199
|
+
return trimObject(value);
|
|
3200
|
+
};
|
|
3201
|
+
|
|
3202
|
+
//#endregion
|
|
3203
|
+
//#region src/namespaces/source/generate/utils.ts
|
|
3204
|
+
const generateAccount = (account) => {
|
|
3205
|
+
if (!isObject(account) || !isNonEmptyString(account.service)) return;
|
|
3206
|
+
const value = {
|
|
3207
|
+
"@service": account.service,
|
|
3208
|
+
"#text": generatePlainString(account.value)
|
|
3209
|
+
};
|
|
3210
|
+
return trimObject(value);
|
|
3211
|
+
};
|
|
3212
|
+
const generateLikes = (likes) => {
|
|
3213
|
+
if (!isObject(likes) || !isNonEmptyString(likes.server)) return;
|
|
3214
|
+
return { "@server": likes.server };
|
|
3215
|
+
};
|
|
3216
|
+
const generateArchive = (archive) => {
|
|
3217
|
+
if (!isObject(archive) || !isNonEmptyString(archive.url) || !isNonEmptyString(archive.startDay)) return;
|
|
3218
|
+
const value = {
|
|
3219
|
+
"source:url": archive.url,
|
|
3220
|
+
"source:startDay": archive.startDay,
|
|
3221
|
+
"source:endDay": generatePlainString(archive.endDay),
|
|
3222
|
+
"source:filename": generatePlainString(archive.filename)
|
|
3223
|
+
};
|
|
3224
|
+
return trimObject(value);
|
|
3225
|
+
};
|
|
3226
|
+
const generateSubscriptionList = (subscriptionList) => {
|
|
3227
|
+
if (!isObject(subscriptionList) || !isNonEmptyString(subscriptionList.url)) return;
|
|
3228
|
+
const value = {
|
|
3229
|
+
"@url": subscriptionList.url,
|
|
3230
|
+
"#text": generatePlainString(subscriptionList.value)
|
|
3231
|
+
};
|
|
3232
|
+
return trimObject(value);
|
|
3233
|
+
};
|
|
3234
|
+
const generateFeed$4 = (feed) => {
|
|
3235
|
+
if (!isObject(feed)) return;
|
|
3236
|
+
const value = {
|
|
3237
|
+
"source:account": trimArray(feed.accounts, generateAccount),
|
|
3238
|
+
"source:likes": generateLikes(feed.likes),
|
|
3239
|
+
"source:archive": generateArchive(feed.archive),
|
|
3240
|
+
"source:subscriptionList": trimArray(feed.subscriptionLists, generateSubscriptionList),
|
|
3241
|
+
"source:cloud": generatePlainString(feed.cloud),
|
|
3242
|
+
"source:blogroll": generatePlainString(feed.blogroll),
|
|
3243
|
+
"source:self": generatePlainString(feed.self)
|
|
3244
|
+
};
|
|
3245
|
+
return trimObject(value);
|
|
3246
|
+
};
|
|
3247
|
+
const generateItem$5 = (item) => {
|
|
3248
|
+
if (!isObject(item)) return;
|
|
3249
|
+
const value = {
|
|
3250
|
+
"source:markdown": generateCdataString(item.markdown),
|
|
3251
|
+
"source:outline": trimArray(item.outlines, generateCdataString),
|
|
3252
|
+
"source:localTime": generatePlainString(item.localTime),
|
|
3253
|
+
"source:linkFull": generatePlainString(item.linkFull)
|
|
3254
|
+
};
|
|
3255
|
+
return trimObject(value);
|
|
3256
|
+
};
|
|
3257
|
+
|
|
3258
|
+
//#endregion
|
|
3259
|
+
//#region src/feeds/rss/generate/utils.ts
|
|
3260
|
+
const generatePerson = (person) => {
|
|
3261
|
+
return generateCdataString(person);
|
|
3262
|
+
};
|
|
3263
|
+
const generateCategory = (category) => {
|
|
3264
|
+
if (!isObject(category)) return;
|
|
3265
|
+
const value = {
|
|
3266
|
+
"@domain": generatePlainString(category.domain),
|
|
3267
|
+
"#text": generateCdataString(category.name)
|
|
3268
|
+
};
|
|
3269
|
+
return trimObject(value);
|
|
3270
|
+
};
|
|
3271
|
+
const generateCloud = (cloud) => {
|
|
3272
|
+
if (!isObject(cloud)) return;
|
|
3273
|
+
const value = {
|
|
3274
|
+
"@domain": generatePlainString(cloud.domain),
|
|
3275
|
+
"@port": generateNumber(cloud.port),
|
|
3276
|
+
"@path": generatePlainString(cloud.path),
|
|
3277
|
+
"@registerProcedure": generatePlainString(cloud.registerProcedure),
|
|
3278
|
+
"@protocol": generatePlainString(cloud.protocol)
|
|
3279
|
+
};
|
|
3280
|
+
return trimObject(value);
|
|
3281
|
+
};
|
|
3282
|
+
const generateImage = (image) => {
|
|
3283
|
+
if (!isObject(image)) return;
|
|
3284
|
+
const value = {
|
|
3285
|
+
url: generateCdataString(image.url),
|
|
3286
|
+
title: generateCdataString(image.title),
|
|
3287
|
+
link: generateCdataString(image.link),
|
|
3288
|
+
description: generateCdataString(image.description),
|
|
3289
|
+
height: generateNumber(image.height),
|
|
3290
|
+
width: generateNumber(image.width)
|
|
3291
|
+
};
|
|
3292
|
+
return trimObject(value);
|
|
3293
|
+
};
|
|
3294
|
+
const generateTextInput = (textInput) => {
|
|
3295
|
+
if (!isObject(textInput)) return;
|
|
3296
|
+
const value = {
|
|
3297
|
+
title: generateCdataString(textInput.title),
|
|
3298
|
+
description: generateCdataString(textInput.description),
|
|
3299
|
+
name: generateCdataString(textInput.name),
|
|
3300
|
+
link: generateCdataString(textInput.link)
|
|
3301
|
+
};
|
|
3302
|
+
return trimObject(value);
|
|
3303
|
+
};
|
|
3304
|
+
const generateEnclosure = (enclosure) => {
|
|
3305
|
+
if (!isObject(enclosure)) return;
|
|
3306
|
+
const value = {
|
|
3307
|
+
"@url": generatePlainString(enclosure.url),
|
|
3308
|
+
"@length": generateNumber(enclosure.length),
|
|
3309
|
+
"@type": generatePlainString(enclosure.type)
|
|
3310
|
+
};
|
|
3311
|
+
return trimObject(value);
|
|
3312
|
+
};
|
|
3313
|
+
const generateSkipHours = (skipHours) => {
|
|
3314
|
+
const value = { hour: trimArray(skipHours, generateNumber) };
|
|
3315
|
+
return trimObject(value);
|
|
3316
|
+
};
|
|
3317
|
+
const generateSkipDays = (skipDays) => {
|
|
3318
|
+
const value = { day: trimArray(skipDays, generatePlainString) };
|
|
3319
|
+
return trimObject(value);
|
|
3320
|
+
};
|
|
3321
|
+
const generateGuid = (guid) => {
|
|
3322
|
+
const value = {
|
|
3323
|
+
"#text": generateCdataString(guid?.value),
|
|
3324
|
+
"@isPermaLink": generateBoolean(guid?.isPermaLink)
|
|
3325
|
+
};
|
|
3326
|
+
return trimObject(value);
|
|
3327
|
+
};
|
|
3328
|
+
const generateSource = (source) => {
|
|
3329
|
+
if (!isObject(source)) return;
|
|
3330
|
+
const value = {
|
|
3331
|
+
"#text": generateCdataString(source.title),
|
|
3332
|
+
"@url": generatePlainString(source.url)
|
|
3333
|
+
};
|
|
3334
|
+
return trimObject(value);
|
|
3335
|
+
};
|
|
3336
|
+
const generateItem$8 = (item) => {
|
|
3337
|
+
if (!isObject(item)) return;
|
|
3338
|
+
const value = {
|
|
3339
|
+
title: generateCdataString(item.title),
|
|
3340
|
+
link: generateCdataString(item.link),
|
|
3341
|
+
description: generateCdataString(item.description),
|
|
3342
|
+
author: trimArray(item.authors, generatePerson),
|
|
3343
|
+
category: trimArray(item.categories, generateCategory),
|
|
3344
|
+
comments: generateCdataString(item.comments),
|
|
3345
|
+
enclosure: trimArray(item.enclosures, generateEnclosure),
|
|
3346
|
+
guid: generateGuid(item.guid),
|
|
3347
|
+
pubDate: generateRfc822Date(item.pubDate),
|
|
3348
|
+
source: generateSource(item.source),
|
|
3349
|
+
...generateEntry(item.atom),
|
|
3350
|
+
...generateItemOrFeed(item.dc),
|
|
3351
|
+
...generateItem(item.content),
|
|
3352
|
+
...generateItem$4(item.slash),
|
|
3353
|
+
...generateItem$1(item.itunes),
|
|
3354
|
+
...generateItem$2(item.podcast),
|
|
3355
|
+
...generateItem$3(item.psc),
|
|
3356
|
+
...generateItemOrFeed$3(item.media),
|
|
3357
|
+
...generateItemOrFeed$2(item.georss),
|
|
3358
|
+
...generateItem$6(item.thr),
|
|
3359
|
+
...generateItemOrFeed$1(item.dcterms),
|
|
3360
|
+
...generateItem$7(item.wfw),
|
|
3361
|
+
...generateItem$5(item.src)
|
|
3362
|
+
};
|
|
3363
|
+
return trimObject(value);
|
|
3364
|
+
};
|
|
3365
|
+
const generateFeed = (feed) => {
|
|
3366
|
+
if (!isObject(feed)) return;
|
|
3367
|
+
const value = {
|
|
3368
|
+
title: generateCdataString(feed.title),
|
|
3369
|
+
link: generateCdataString(feed.link),
|
|
3370
|
+
description: generateCdataString(feed.description),
|
|
3371
|
+
language: generateCdataString(feed.language),
|
|
3372
|
+
copyright: generateCdataString(feed.copyright),
|
|
3373
|
+
managingEditor: generatePerson(feed.managingEditor),
|
|
3374
|
+
webMaster: generatePerson(feed.webMaster),
|
|
3375
|
+
pubDate: generateRfc822Date(feed.pubDate),
|
|
3376
|
+
lastBuildDate: generateRfc822Date(feed.lastBuildDate),
|
|
3377
|
+
category: trimArray(feed.categories, generateCategory),
|
|
3378
|
+
generator: generateCdataString(feed.generator),
|
|
3379
|
+
docs: generateCdataString(feed.docs),
|
|
3380
|
+
cloud: generateCloud(feed.cloud),
|
|
3381
|
+
ttl: generateNumber(feed.ttl),
|
|
3382
|
+
image: generateImage(feed.image),
|
|
3383
|
+
rating: generateCdataString(feed.rating),
|
|
3384
|
+
textInput: generateTextInput(feed.textInput),
|
|
3385
|
+
skipHours: generateSkipHours(feed.skipHours),
|
|
3386
|
+
skipDays: generateSkipDays(feed.skipDays),
|
|
3387
|
+
...generateFeed$1(feed.atom),
|
|
3388
|
+
...generateItemOrFeed(feed.dc),
|
|
3389
|
+
...generateFeed$5(feed.sy),
|
|
3390
|
+
...generateFeed$2(feed.itunes),
|
|
3391
|
+
...generateFeed$3(feed.podcast),
|
|
3392
|
+
...generateItemOrFeed$3(feed.media),
|
|
3393
|
+
...generateItemOrFeed$2(feed.georss),
|
|
3394
|
+
...generateItemOrFeed$1(feed.dcterms),
|
|
3395
|
+
...generateFeed$4(feed.src),
|
|
3396
|
+
item: trimArray(feed.items, generateItem$8)
|
|
3397
|
+
};
|
|
3398
|
+
const trimmedValue = trimObject(value);
|
|
3399
|
+
if (!trimmedValue) return;
|
|
3400
|
+
return { rss: {
|
|
3401
|
+
"@version": "2.0",
|
|
3402
|
+
...generateNamespaceAttrs(trimmedValue, namespaceUrls),
|
|
3403
|
+
channel: trimmedValue
|
|
3404
|
+
} };
|
|
3405
|
+
};
|
|
3406
|
+
|
|
3407
|
+
//#endregion
|
|
3408
|
+
//#region src/feeds/rss/generate/index.ts
|
|
3409
|
+
const generate$3 = (value, options) => {
|
|
3410
|
+
const generated = generateFeed(value);
|
|
3411
|
+
if (!generated) throw new Error("Invalid input RSS");
|
|
3412
|
+
return generateXml(builder$1, generated, options);
|
|
3413
|
+
};
|
|
3414
|
+
|
|
3415
|
+
//#endregion
|
|
3416
|
+
//#region src/opml/generate/config.ts
|
|
3417
|
+
const builder = new XMLBuilder({ ...builderConfig });
|
|
3418
|
+
|
|
3419
|
+
//#endregion
|
|
3420
|
+
//#region src/opml/generate/utils.ts
|
|
3421
|
+
const generateOutline = (outline, options) => {
|
|
3422
|
+
if (!isObject(outline)) return;
|
|
3423
|
+
const value = {
|
|
3424
|
+
"@text": generatePlainString(outline.text),
|
|
3425
|
+
"@type": generatePlainString(outline.type),
|
|
3426
|
+
"@isComment": generateBoolean(outline.isComment),
|
|
3427
|
+
"@isBreakpoint": generateBoolean(outline.isBreakpoint),
|
|
3428
|
+
"@created": generateRfc822Date(outline.created),
|
|
3429
|
+
"@category": generatePlainString(outline.category),
|
|
3430
|
+
"@description": generatePlainString(outline.description),
|
|
3431
|
+
"@xmlUrl": generatePlainString(outline.xmlUrl),
|
|
3432
|
+
"@htmlUrl": generatePlainString(outline.htmlUrl),
|
|
3433
|
+
"@language": generatePlainString(outline.language),
|
|
3434
|
+
"@title": generatePlainString(outline.title),
|
|
3435
|
+
"@version": generatePlainString(outline.version),
|
|
3436
|
+
"@url": generatePlainString(outline.url),
|
|
3437
|
+
outline: trimArray(outline.outlines, (item) => generateOutline(item, options))
|
|
3438
|
+
};
|
|
3439
|
+
if (options?.extraOutlineAttributes) for (const attribute of options.extraOutlineAttributes) {
|
|
3440
|
+
const attributeKey = `@${attribute}`;
|
|
3441
|
+
if (!isPresent(outline[attribute])) continue;
|
|
3442
|
+
value[attributeKey] = generatePlainString(outline[attribute]);
|
|
3443
|
+
}
|
|
3444
|
+
return trimObject(value);
|
|
3445
|
+
};
|
|
3446
|
+
const generateHead = (head) => {
|
|
3447
|
+
if (!isObject(head)) return;
|
|
3448
|
+
const value = {
|
|
3449
|
+
title: generateCdataString(head.title),
|
|
3450
|
+
dateCreated: generateRfc822Date(head.dateCreated),
|
|
3451
|
+
dateModified: generateRfc822Date(head.dateModified),
|
|
3452
|
+
ownerName: generateCdataString(head.ownerName),
|
|
3453
|
+
ownerEmail: generateCdataString(head.ownerEmail),
|
|
3454
|
+
ownerId: generateCdataString(head.ownerId),
|
|
3455
|
+
docs: generateCdataString(head.docs),
|
|
3456
|
+
expansionState: generateCsvOf(head.expansionState, generateNumber),
|
|
3457
|
+
vertScrollState: generateNumber(head.vertScrollState),
|
|
3458
|
+
windowTop: generateNumber(head.windowTop),
|
|
3459
|
+
windowLeft: generateNumber(head.windowLeft),
|
|
3460
|
+
windowBottom: generateNumber(head.windowBottom),
|
|
3461
|
+
windowRight: generateNumber(head.windowRight)
|
|
3462
|
+
};
|
|
3463
|
+
return trimObject(value);
|
|
3464
|
+
};
|
|
3465
|
+
const generateBody = (body, options) => {
|
|
3466
|
+
if (!isObject(body)) return;
|
|
3467
|
+
const value = { outline: trimArray(body.outlines, (item) => generateOutline(item, options)) };
|
|
3468
|
+
return trimObject(value);
|
|
3469
|
+
};
|
|
3470
|
+
const generateOpml = (opml, options) => {
|
|
3471
|
+
if (!isObject(opml)) return;
|
|
3472
|
+
const value = trimObject({
|
|
3473
|
+
"@version": "2.0",
|
|
3474
|
+
head: generateHead(opml.head),
|
|
3475
|
+
body: generateBody(opml.body, options)
|
|
3476
|
+
});
|
|
3477
|
+
if (value?.body !== void 0) return { opml: value };
|
|
3478
|
+
};
|
|
3479
|
+
|
|
3480
|
+
//#endregion
|
|
3481
|
+
//#region src/opml/generate/index.ts
|
|
3482
|
+
const generate$2 = (value, options) => {
|
|
3483
|
+
const generated = generateOpml(value, options);
|
|
3484
|
+
if (!generated) throw new Error("Invalid input OPML");
|
|
3485
|
+
return generateXml(builder, generated, options);
|
|
3486
|
+
};
|
|
3487
|
+
|
|
3488
|
+
//#endregion
|
|
3489
|
+
//#region src/opml/parse/config.ts
|
|
3490
|
+
const stopNodes = [
|
|
3491
|
+
"opml.head.title",
|
|
3492
|
+
"opml.head.dateCreated",
|
|
3493
|
+
"opml.head.dateModified",
|
|
3494
|
+
"opml.head.ownerName",
|
|
3495
|
+
"opml.head.ownerEmail",
|
|
3496
|
+
"opml.head.ownerId",
|
|
3497
|
+
"opml.head.docs",
|
|
3498
|
+
"opml.head.expansionState",
|
|
3499
|
+
"opml.head.vertScrollState",
|
|
3500
|
+
"opml.head.windowTop",
|
|
3501
|
+
"opml.head.windowLeft",
|
|
3502
|
+
"opml.head.windowBottom",
|
|
3503
|
+
"opml.head.windowRight",
|
|
3504
|
+
"*.outline.outline"
|
|
3505
|
+
];
|
|
3506
|
+
const parser = new XMLParser({
|
|
3507
|
+
...parserConfig,
|
|
3508
|
+
stopNodes
|
|
3509
|
+
});
|
|
3510
|
+
|
|
3511
|
+
//#endregion
|
|
3512
|
+
//#region src/opml/parse/utils.ts
|
|
3513
|
+
const parseOutline = (value, options) => {
|
|
3514
|
+
if (!isObject(value)) return;
|
|
3515
|
+
const outline = {
|
|
3516
|
+
text: parseString(value["@text"]),
|
|
3517
|
+
type: parseString(value["@type"]),
|
|
3518
|
+
isComment: parseBoolean(value["@iscomment"]),
|
|
3519
|
+
isBreakpoint: parseBoolean(value["@isbreakpoint"]),
|
|
3520
|
+
created: parseDate(value["@created"]),
|
|
3521
|
+
category: parseString(value["@category"]),
|
|
3522
|
+
description: parseString(value["@description"]),
|
|
3523
|
+
xmlUrl: parseString(value["@xmlurl"]),
|
|
3524
|
+
htmlUrl: parseString(value["@htmlurl"]),
|
|
3525
|
+
language: parseString(value["@language"]),
|
|
3526
|
+
title: parseString(value["@title"]),
|
|
3527
|
+
version: parseString(value["@version"]),
|
|
3528
|
+
url: parseString(value["@url"]),
|
|
3529
|
+
outlines: parseArrayOf(value.outline, (value$1) => parseOutline(value$1, options))
|
|
3530
|
+
};
|
|
3531
|
+
if (options?.extraOutlineAttributes) for (const attribute of options.extraOutlineAttributes) {
|
|
3532
|
+
const attributeKey = `@${attribute.toLowerCase()}`;
|
|
3533
|
+
if (!isPresent(value[attributeKey])) continue;
|
|
3534
|
+
outline[attribute] = parseString(value[attributeKey]);
|
|
3535
|
+
}
|
|
3536
|
+
return trimObject(outline);
|
|
3537
|
+
};
|
|
3538
|
+
const parseHead = (value) => {
|
|
3539
|
+
if (!isObject(value)) return;
|
|
3540
|
+
const head = {
|
|
3541
|
+
title: parseSingularOf(value.title, (value$1) => parseString(retrieveText(value$1))),
|
|
3542
|
+
dateCreated: parseSingularOf(value.datecreated, (value$1) => parseDate(retrieveText(value$1))),
|
|
3543
|
+
dateModified: parseSingularOf(value.datemodified, (value$1) => parseDate(retrieveText(value$1))),
|
|
3544
|
+
ownerName: parseSingularOf(value.ownername, (value$1) => parseString(retrieveText(value$1))),
|
|
3545
|
+
ownerEmail: parseSingularOf(value.owneremail, (value$1) => parseString(retrieveText(value$1))),
|
|
3546
|
+
ownerId: parseSingularOf(value.ownerid, (value$1) => parseString(retrieveText(value$1))),
|
|
3547
|
+
docs: parseSingularOf(value.docs, (value$1) => parseString(retrieveText(value$1))),
|
|
3548
|
+
expansionState: parseSingularOf(value.expansionstate, (value$1) => parseCsvOf(retrieveText(value$1), parseNumber)),
|
|
3549
|
+
vertScrollState: parseSingularOf(value.vertscrollstate, (value$1) => parseNumber(retrieveText(value$1))),
|
|
3550
|
+
windowTop: parseSingularOf(value.windowtop, (value$1) => parseNumber(retrieveText(value$1))),
|
|
3551
|
+
windowLeft: parseSingularOf(value.windowleft, (value$1) => parseNumber(retrieveText(value$1))),
|
|
3552
|
+
windowBottom: parseSingularOf(value.windowbottom, (value$1) => parseNumber(retrieveText(value$1))),
|
|
3553
|
+
windowRight: parseSingularOf(value.windowright, (value$1) => parseNumber(retrieveText(value$1)))
|
|
3554
|
+
};
|
|
3555
|
+
return trimObject(head);
|
|
3556
|
+
};
|
|
3557
|
+
const parseBody = (value, options) => {
|
|
3558
|
+
if (!isObject(value)) return;
|
|
3559
|
+
const body = { outlines: parseArrayOf(value.outline, (value$1) => parseOutline(value$1, options)) };
|
|
3560
|
+
return trimObject(body);
|
|
3561
|
+
};
|
|
3562
|
+
const parseOpml = (value, options) => {
|
|
3563
|
+
if (!isObject(value?.opml)) return;
|
|
3564
|
+
const opml = {
|
|
3565
|
+
head: parseHead(value.opml.head),
|
|
3566
|
+
body: parseBody(value.opml.body, options)
|
|
3567
|
+
};
|
|
3568
|
+
return trimObject(opml);
|
|
3569
|
+
};
|
|
3570
|
+
|
|
3571
|
+
//#endregion
|
|
3572
|
+
//#region src/opml/parse/index.ts
|
|
3573
|
+
const parse$3 = (value, options) => {
|
|
3574
|
+
const object = parser.parse(value);
|
|
3575
|
+
const parsed = parseOpml(object, options);
|
|
3576
|
+
if (!parsed) throw new Error("Invalid OPML format");
|
|
3577
|
+
return parsed;
|
|
3578
|
+
};
|
|
3579
|
+
|
|
3580
|
+
//#endregion
|
|
3581
|
+
export { detect as detectAtomFeed, detect$1 as detectJsonFeed, detect$2 as detectRdfFeed, detect$3 as detectRssFeed, generate as generateAtomFeed, generate$1 as generateJsonFeed, generate$2 as generateOpml, generate$3 as generateRssFeed, parse as parseAtomFeed, parse$1 as parseFeed, parse$2 as parseJsonFeed, parse$3 as parseOpml, parse$4 as parseRdfFeed, parse$5 as parseRssFeed };
|