source: trip-planner-front/node_modules/source-map-resolve/source-map-resolve.js@ b738035

Last change on this file since b738035 was e29cc2e, checked in by Ema <ema_spirova@…>, 3 years ago

primeNG components
  • Property mode set to 100644
File size: 9.5 KB
Line 
1// Note: source-map-resolve.js is generated from source-map-resolve-node.js and
2// source-map-resolve-template.js. Only edit the two latter files, _not_
3// source-map-resolve.js!
4
5void (function(root, factory) {
6 if (typeof define === "function" && define.amd) {
7 define(["source-map-url", "resolve-url"], factory)
8 } else if (typeof exports === "object") {
9 var sourceMappingURL = require("source-map-url")
10 var resolveUrl = require("resolve-url")
11 module.exports = factory(sourceMappingURL, resolveUrl)
12 } else {
13 root.sourceMapResolve = factory(root.sourceMappingURL, root.resolveUrl)
14 }
15}(this, function(sourceMappingURL, resolveUrl) {
16
17 function callbackAsync(callback, error, result) {
18 setImmediate(function() { callback(error, result) })
19 }
20
21 function parseMapToJSON(string, data) {
22 try {
23 return JSON.parse(string.replace(/^\)\]\}'/, ""))
24 } catch (error) {
25 error.sourceMapData = data
26 throw error
27 }
28 }
29
30 function readSync(read, url, data) {
31 var readUrl = url
32 try {
33 return String(read(readUrl))
34 } catch (error) {
35 error.sourceMapData = data
36 throw error
37 }
38 }
39
40
41
42 function resolveSourceMap(code, codeUrl, read, callback) {
43 var mapData
44 try {
45 mapData = resolveSourceMapHelper(code, codeUrl)
46 } catch (error) {
47 return callbackAsync(callback, error)
48 }
49 if (!mapData || mapData.map) {
50 return callbackAsync(callback, null, mapData)
51 }
52 var readUrl = mapData.url
53 read(readUrl, function(error, result) {
54 if (error) {
55 error.sourceMapData = mapData
56 return callback(error)
57 }
58 mapData.map = String(result)
59 try {
60 mapData.map = parseMapToJSON(mapData.map, mapData)
61 } catch (error) {
62 return callback(error)
63 }
64 callback(null, mapData)
65 })
66 }
67
68 function resolveSourceMapSync(code, codeUrl, read) {
69 var mapData = resolveSourceMapHelper(code, codeUrl)
70 if (!mapData || mapData.map) {
71 return mapData
72 }
73 mapData.map = readSync(read, mapData.url, mapData)
74 mapData.map = parseMapToJSON(mapData.map, mapData)
75 return mapData
76 }
77
78 var dataUriRegex = /^data:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
79
80 /**
81 * The media type for JSON text is application/json.
82 *
83 * {@link https://tools.ietf.org/html/rfc8259#section-11 | IANA Considerations }
84 *
85 * `text/json` is non-standard media type
86 */
87 var jsonMimeTypeRegex = /^(?:application|text)\/json$/
88
89 /**
90 * JSON text exchanged between systems that are not part of a closed ecosystem
91 * MUST be encoded using UTF-8.
92 *
93 * {@link https://tools.ietf.org/html/rfc8259#section-8.1 | Character Encoding}
94 */
95 var jsonCharacterEncoding = "utf-8"
96
97 function base64ToBuf(b64) {
98 var binStr = atob(b64)
99 var len = binStr.length
100 var arr = new Uint8Array(len)
101 for (var i = 0; i < len; i++) {
102 arr[i] = binStr.charCodeAt(i)
103 }
104 return arr
105 }
106
107 function decodeBase64String(b64) {
108 if (typeof TextDecoder === "undefined" || typeof Uint8Array === "undefined") {
109 return atob(b64)
110 }
111 var buf = base64ToBuf(b64);
112 // Note: `decoder.decode` method will throw a `DOMException` with the
113 // `"EncodingError"` value when an coding error is found.
114 var decoder = new TextDecoder(jsonCharacterEncoding, {fatal: true})
115 return decoder.decode(buf);
116 }
117
118 function resolveSourceMapHelper(code, codeUrl) {
119 var url = sourceMappingURL.getFrom(code)
120 if (!url) {
121 return null
122 }
123
124 var dataUri = url.match(dataUriRegex)
125 if (dataUri) {
126 var mimeType = dataUri[1] || "text/plain"
127 var lastParameter = dataUri[2] || ""
128 var encoded = dataUri[3] || ""
129 var data = {
130 sourceMappingURL: url,
131 url: null,
132 sourcesRelativeTo: codeUrl,
133 map: encoded
134 }
135 if (!jsonMimeTypeRegex.test(mimeType)) {
136 var error = new Error("Unuseful data uri mime type: " + mimeType)
137 error.sourceMapData = data
138 throw error
139 }
140 try {
141 data.map = parseMapToJSON(
142 lastParameter === ";base64" ? decodeBase64String(encoded) : decodeURIComponent(encoded),
143 data
144 )
145 } catch (error) {
146 error.sourceMapData = data
147 throw error
148 }
149 return data
150 }
151
152 var mapUrl = resolveUrl(codeUrl, url)
153 return {
154 sourceMappingURL: url,
155 url: mapUrl,
156 sourcesRelativeTo: mapUrl,
157 map: null
158 }
159 }
160
161
162
163 function resolveSources(map, mapUrl, read, options, callback) {
164 if (typeof options === "function") {
165 callback = options
166 options = {}
167 }
168 var pending = map.sources ? map.sources.length : 0
169 var result = {
170 sourcesResolved: [],
171 sourcesContent: []
172 }
173
174 if (pending === 0) {
175 callbackAsync(callback, null, result)
176 return
177 }
178
179 var done = function() {
180 pending--
181 if (pending === 0) {
182 callback(null, result)
183 }
184 }
185
186 resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
187 result.sourcesResolved[index] = fullUrl
188 if (typeof sourceContent === "string") {
189 result.sourcesContent[index] = sourceContent
190 callbackAsync(done, null)
191 } else {
192 var readUrl = fullUrl
193 read(readUrl, function(error, source) {
194 result.sourcesContent[index] = error ? error : String(source)
195 done()
196 })
197 }
198 })
199 }
200
201 function resolveSourcesSync(map, mapUrl, read, options) {
202 var result = {
203 sourcesResolved: [],
204 sourcesContent: []
205 }
206
207 if (!map.sources || map.sources.length === 0) {
208 return result
209 }
210
211 resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
212 result.sourcesResolved[index] = fullUrl
213 if (read !== null) {
214 if (typeof sourceContent === "string") {
215 result.sourcesContent[index] = sourceContent
216 } else {
217 var readUrl = fullUrl
218 try {
219 result.sourcesContent[index] = String(read(readUrl))
220 } catch (error) {
221 result.sourcesContent[index] = error
222 }
223 }
224 }
225 })
226
227 return result
228 }
229
230 var endingSlash = /\/?$/
231
232 function resolveSourcesHelper(map, mapUrl, options, fn) {
233 options = options || {}
234 var fullUrl
235 var sourceContent
236 var sourceRoot
237 for (var index = 0, len = map.sources.length; index < len; index++) {
238 sourceRoot = null
239 if (typeof options.sourceRoot === "string") {
240 sourceRoot = options.sourceRoot
241 } else if (typeof map.sourceRoot === "string" && options.sourceRoot !== false) {
242 sourceRoot = map.sourceRoot
243 }
244 // If the sourceRoot is the empty string, it is equivalent to not setting
245 // the property at all.
246 if (sourceRoot === null || sourceRoot === '') {
247 fullUrl = resolveUrl(mapUrl, map.sources[index])
248 } else {
249 // Make sure that the sourceRoot ends with a slash, so that `/scripts/subdir` becomes
250 // `/scripts/subdir/<source>`, not `/scripts/<source>`. Pointing to a file as source root
251 // does not make sense.
252 fullUrl = resolveUrl(mapUrl, sourceRoot.replace(endingSlash, "/"), map.sources[index])
253 }
254 sourceContent = (map.sourcesContent || [])[index]
255 fn(fullUrl, sourceContent, index)
256 }
257 }
258
259
260
261 function resolve(code, codeUrl, read, options, callback) {
262 if (typeof options === "function") {
263 callback = options
264 options = {}
265 }
266 if (code === null) {
267 var mapUrl = codeUrl
268 var data = {
269 sourceMappingURL: null,
270 url: mapUrl,
271 sourcesRelativeTo: mapUrl,
272 map: null
273 }
274 var readUrl = mapUrl
275 read(readUrl, function(error, result) {
276 if (error) {
277 error.sourceMapData = data
278 return callback(error)
279 }
280 data.map = String(result)
281 try {
282 data.map = parseMapToJSON(data.map, data)
283 } catch (error) {
284 return callback(error)
285 }
286 _resolveSources(data)
287 })
288 } else {
289 resolveSourceMap(code, codeUrl, read, function(error, mapData) {
290 if (error) {
291 return callback(error)
292 }
293 if (!mapData) {
294 return callback(null, null)
295 }
296 _resolveSources(mapData)
297 })
298 }
299
300 function _resolveSources(mapData) {
301 resolveSources(mapData.map, mapData.sourcesRelativeTo, read, options, function(error, result) {
302 if (error) {
303 return callback(error)
304 }
305 mapData.sourcesResolved = result.sourcesResolved
306 mapData.sourcesContent = result.sourcesContent
307 callback(null, mapData)
308 })
309 }
310 }
311
312 function resolveSync(code, codeUrl, read, options) {
313 var mapData
314 if (code === null) {
315 var mapUrl = codeUrl
316 mapData = {
317 sourceMappingURL: null,
318 url: mapUrl,
319 sourcesRelativeTo: mapUrl,
320 map: null
321 }
322 mapData.map = readSync(read, mapUrl, mapData)
323 mapData.map = parseMapToJSON(mapData.map, mapData)
324 } else {
325 mapData = resolveSourceMapSync(code, codeUrl, read)
326 if (!mapData) {
327 return null
328 }
329 }
330 var result = resolveSourcesSync(mapData.map, mapData.sourcesRelativeTo, read, options)
331 mapData.sourcesResolved = result.sourcesResolved
332 mapData.sourcesContent = result.sourcesContent
333 return mapData
334 }
335
336
337
338 return {
339 resolveSourceMap: resolveSourceMap,
340 resolveSourceMapSync: resolveSourceMapSync,
341 resolveSources: resolveSources,
342 resolveSourcesSync: resolveSourcesSync,
343 resolve: resolve,
344 resolveSync: resolveSync,
345 parseMapToJSON: parseMapToJSON
346 }
347
348}));
Note: See TracBrowser for help on using the repository browser.