mario/config-pacs-docker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
mario
2025-02-26 14:49:25 +07:00
commit 1c1d9c4474
6403 changed files with 1953774 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

626
nv/html/nv-nopdf/styles/packages/ohif_wadoproxy.js Normal file
View File

@@ -0,0 +1,626 @@
//////////////////////////////////////////////////////////////////////////
// //
// This is a generated file. You can view the original //
// source in your browser if your browser supports source maps. //
// Source maps are supported by all recent versions of Chrome, Safari, //
// and Firefox, and by Internet Explorer 11. //
// //
//////////////////////////////////////////////////////////////////////////
(function () {
/* Imports */
var Meteor = Package.meteor.Meteor;
var global = Package.meteor.global;
var meteorEnv = Package.meteor.meteorEnv;
var Router = Package['clinical:router'].Router;
var RouteController = Package['clinical:router'].RouteController;
var meteorInstall = Package.modules.meteorInstall;
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
var Promise = Package.promise.Promise;
var Iron = Package['iron:core'].Iron;
var Symbol = Package['ecmascript-runtime-client'].Symbol;
var Map = Package['ecmascript-runtime-client'].Map;
var Set = Package['ecmascript-runtime-client'].Set;
/* Package-scope variables */
var WADOProxy;
var require = meteorInstall({"node_modules":{"meteor":{"ohif:wadoproxy":{"both":{"namespace.js":function(){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/ohif_wadoproxy/both/namespace.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
WADOProxy = {};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"convertURL.js":function(require,exports,module){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/ohif_wadoproxy/both/convertURL.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
var queryString;
module.watch(require("query-string"), {
"default": function (v) {
queryString = v;
}
}, 0);
WADOProxy.convertURL = function (url, serverConfiguration) {
if (!url) {
return null;
}
if (serverConfiguration.requestOptions && serverConfiguration.requestOptions.requestFromBrowser === true) {
return url;
}
var _WADOProxy = WADOProxy,
settings = _WADOProxy.settings;
var serverId = serverConfiguration._id;
var query = queryString.stringify({
url: url,
serverId: serverId
});
return settings.uri + "?" + query;
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"initialize.js":function(require,exports,module){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// packages/ohif_wadoproxy/both/initialize.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
var Meteor;
module.watch(require("meteor/meteor"), {
Meteor: function (v) {
Meteor = v;
}
}, 0);
var OHIF;
module.watch(require("meteor/ohif:core"), {
OHIF: function (v) {
OHIF = v;
}
}, 1);
WADOProxy.settings = Object.assign({
uri: OHIF.utils.absoluteUrl("/__wado_proxy")
}, Meteor.settings && Meteor.settings.proxy ? Meteor.settings.proxy : {});
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}},"node_modules":{"query-string":{"package.json":function(require,exports){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/query-string/package.json //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
exports.name = "query-string";
exports.version = "5.1.1";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"index.js":function(require,exports){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/query-string/index.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
'use strict';
var strictUriEncode = require('strict-uri-encode');
var objectAssign = require('object-assign');
var decodeComponent = require('decode-uri-component');
function encoderForArrayFormat(opts) {
switch (opts.arrayFormat) {
case 'index':
return function (key, value, index) {
return value === null ? [
encode(key, opts),
'[',
index,
']'
].join('') : [
encode(key, opts),
'[',
encode(index, opts),
']=',
encode(value, opts)
].join('');
};
case 'bracket':
return function (key, value) {
return value === null ? encode(key, opts) : [
encode(key, opts),
'[]=',
encode(value, opts)
].join('');
};
default:
return function (key, value) {
return value === null ? encode(key, opts) : [
encode(key, opts),
'=',
encode(value, opts)
].join('');
};
}
}
function parserForArrayFormat(opts) {
var result;
switch (opts.arrayFormat) {
case 'index':
return function (key, value, accumulator) {
result = /\[(\d*)\]$/.exec(key);
key = key.replace(/\[\d*\]$/, '');
if (!result) {
accumulator[key] = value;
return;
}
if (accumulator[key] === undefined) {
accumulator[key] = {};
}
accumulator[key][result[1]] = value;
};
case 'bracket':
return function (key, value, accumulator) {
result = /(\[\])$/.exec(key);
key = key.replace(/\[\]$/, '');
if (!result) {
accumulator[key] = value;
return;
} else if (accumulator[key] === undefined) {
accumulator[key] = [value];
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
default:
return function (key, value, accumulator) {
if (accumulator[key] === undefined) {
accumulator[key] = value;
return;
}
accumulator[key] = [].concat(accumulator[key], value);
};
}
}
function encode(value, opts) {
if (opts.encode) {
return opts.strict ? strictUriEncode(value) : encodeURIComponent(value);
}
return value;
}
function keysSorter(input) {
if (Array.isArray(input)) {
return input.sort();
} else if (typeof input === 'object') {
return keysSorter(Object.keys(input)).sort(function (a, b) {
return Number(a) - Number(b);
}).map(function (key) {
return input[key];
});
}
return input;
}
function extract(str) {
var queryStart = str.indexOf('?');
if (queryStart === -1) {
return '';
}
return str.slice(queryStart + 1);
}
function parse(str, opts) {
opts = objectAssign({arrayFormat: 'none'}, opts);
var formatter = parserForArrayFormat(opts);
// Create an object with no prototype
// https://github.com/sindresorhus/query-string/issues/47
var ret = Object.create(null);
if (typeof str !== 'string') {
return ret;
}
str = str.trim().replace(/^[?#&]/, '');
if (!str) {
return ret;
}
str.split('&').forEach(function (param) {
var parts = param.replace(/\+/g, ' ').split('=');
// Firefox (pre 40) decodes `%3D` to `=`
// https://github.com/sindresorhus/query-string/pull/37
var key = parts.shift();
var val = parts.length > 0 ? parts.join('=') : undefined;
// missing `=` should be `null`:
// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
val = val === undefined ? null : decodeComponent(val);
formatter(decodeComponent(key), val, ret);
});
return Object.keys(ret).sort().reduce(function (result, key) {
var val = ret[key];
if (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) {
// Sort object keys, not values
result[key] = keysSorter(val);
} else {
result[key] = val;
}
return result;
}, Object.create(null));
}
exports.extract = extract;
exports.parse = parse;
exports.stringify = function (obj, opts) {
var defaults = {
encode: true,
strict: true,
arrayFormat: 'none'
};
opts = objectAssign(defaults, opts);
if (opts.sort === false) {
opts.sort = function () {};
}
var formatter = encoderForArrayFormat(opts);
return obj ? Object.keys(obj).sort(opts.sort).map(function (key) {
var val = obj[key];
if (val === undefined) {
return '';
}
if (val === null) {
return encode(key, opts);
}
if (Array.isArray(val)) {
var result = [];
val.slice().forEach(function (val2) {
if (val2 === undefined) {
return;
}
result.push(formatter(key, val2, result.length));
});
return result.join('&');
}
return encode(key, opts) + '=' + encode(val, opts);
}).filter(function (x) {
return x.length > 0;
}).join('&') : '';
};
exports.parseUrl = function (str, opts) {
return {
url: str.split('?')[0] || '',
query: parse(extract(str), opts)
};
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}},"strict-uri-encode":{"package.json":function(require,exports){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/strict-uri-encode/package.json //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
exports.name = "strict-uri-encode";
exports.version = "1.1.0";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"index.js":function(require,exports,module){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/strict-uri-encode/index.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
'use strict';
module.exports = function (str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
return '%' + c.charCodeAt(0).toString(16).toUpperCase();
});
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}},"object-assign":{"package.json":function(require,exports){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/object-assign/package.json //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
exports.name = "object-assign";
exports.version = "4.1.1";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"index.js":function(require,exports,module){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/object-assign/index.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
'use strict';
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or undefined');
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
// Detect buggy property enumeration order in older V8 versions.
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
test1[5] = 'de';
if (Object.getOwnPropertyNames(test1)[0] === '5') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test2 = {};
for (var i = 0; i < 10; i++) {
test2['_' + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
return test2[n];
});
if (order2.join('') !== '0123456789') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test3 = {};
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join('') !==
'abcdefghijklmnopqrst') {
return false;
}
return true;
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false;
}
}
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}},"decode-uri-component":{"package.json":function(require,exports){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/decode-uri-component/package.json //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
exports.name = "decode-uri-component";
exports.version = "0.2.0";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
},"index.js":function(require,exports,module){
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// node_modules/meteor/ohif_wadoproxy/node_modules/decode-uri-component/index.js //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
'use strict';
var token = '%[a-f0-9]{2}';
var singleMatcher = new RegExp(token, 'gi');
var multiMatcher = new RegExp('(' + token + ')+', 'gi');
function decodeComponents(components, split) {
try {
// Try to decode the entire string first
return decodeURIComponent(components.join(''));
} catch (err) {
// Do nothing
}
if (components.length === 1) {
return components;
}
split = split || 1;
// Split the array in 2 parts
var left = components.slice(0, split);
var right = components.slice(split);
return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
}
function decode(input) {
try {
return decodeURIComponent(input);
} catch (err) {
var tokens = input.match(singleMatcher);
for (var i = 1; i < tokens.length; i++) {
input = decodeComponents(tokens, i).join('');
tokens = input.match(singleMatcher);
}
return input;
}
}
function customDecodeURIComponent(input) {
// Keep track of all the replacements and prefill the map with the `BOM`
var replaceMap = {
'%FE%FF': '\uFFFD\uFFFD',
'%FF%FE': '\uFFFD\uFFFD'
};
var match = multiMatcher.exec(input);
while (match) {
try {
// Decode as big chunks as possible
replaceMap[match[0]] = decodeURIComponent(match[0]);
} catch (err) {
var result = decode(match[0]);
if (result !== match[0]) {
replaceMap[match[0]] = result;
}
}
match = multiMatcher.exec(input);
}
// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
replaceMap['%C2'] = '\uFFFD';
var entries = Object.keys(replaceMap);
for (var i = 0; i < entries.length; i++) {
// Replace all decoded components
var key = entries[i];
input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
}
return input;
}
module.exports = function (encodedURI) {
if (typeof encodedURI !== 'string') {
throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
}
try {
encodedURI = encodedURI.replace(/\+/g, ' ');
// Try the built in decoder first
return decodeURIComponent(encodedURI);
} catch (err) {
// Fallback to a more advanced decoder
return customDecodeURIComponent(encodedURI);
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}}}}}}},{
"extensions": [
".js",
".json"
]
});
require("/node_modules/meteor/ohif:wadoproxy/both/namespace.js");
require("/node_modules/meteor/ohif:wadoproxy/both/convertURL.js");
require("/node_modules/meteor/ohif:wadoproxy/both/initialize.js");
/* Exports */
Package._define("ohif:wadoproxy", {
WADOProxy: WADOProxy
});
})();