61192 lines
2.5 MiB
61192 lines
2.5 MiB
module.exports =
|
||
/******/ (function(modules, runtime) { // webpackBootstrap
|
||
/******/ "use strict";
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId]) {
|
||
/******/ return installedModules[moduleId].exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ i: moduleId,
|
||
/******/ l: false,
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.l = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ __webpack_require__.ab = __dirname + "/";
|
||
/******/
|
||
/******/ // the startup function
|
||
/******/ function startup() {
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(778);
|
||
/******/ };
|
||
/******/
|
||
/******/ // run startup
|
||
/******/ return startup();
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ([
|
||
/* 0 */,
|
||
/* 1 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.findInPath = exports.which = exports.mkdirP = exports.rmRF = exports.mv = exports.cp = void 0;
|
||
const assert_1 = __webpack_require__(357);
|
||
const childProcess = __importStar(__webpack_require__(129));
|
||
const path = __importStar(__webpack_require__(622));
|
||
const util_1 = __webpack_require__(669);
|
||
const ioUtil = __importStar(__webpack_require__(672));
|
||
const exec = util_1.promisify(childProcess.exec);
|
||
const execFile = util_1.promisify(childProcess.execFile);
|
||
/**
|
||
* Copies a file or folder.
|
||
* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
|
||
*
|
||
* @param source source path
|
||
* @param dest destination path
|
||
* @param options optional. See CopyOptions.
|
||
*/
|
||
function cp(source, dest, options = {}) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const { force, recursive, copySourceDirectory } = readCopyOptions(options);
|
||
const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
|
||
// Dest is an existing file, but not forcing
|
||
if (destStat && destStat.isFile() && !force) {
|
||
return;
|
||
}
|
||
// If dest is an existing directory, should copy inside.
|
||
const newDest = destStat && destStat.isDirectory() && copySourceDirectory
|
||
? path.join(dest, path.basename(source))
|
||
: dest;
|
||
if (!(yield ioUtil.exists(source))) {
|
||
throw new Error(`no such file or directory: ${source}`);
|
||
}
|
||
const sourceStat = yield ioUtil.stat(source);
|
||
if (sourceStat.isDirectory()) {
|
||
if (!recursive) {
|
||
throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
|
||
}
|
||
else {
|
||
yield cpDirRecursive(source, newDest, 0, force);
|
||
}
|
||
}
|
||
else {
|
||
if (path.relative(source, newDest) === '') {
|
||
// a file cannot be copied to itself
|
||
throw new Error(`'${newDest}' and '${source}' are the same file`);
|
||
}
|
||
yield copyFile(source, newDest, force);
|
||
}
|
||
});
|
||
}
|
||
exports.cp = cp;
|
||
/**
|
||
* Moves a path.
|
||
*
|
||
* @param source source path
|
||
* @param dest destination path
|
||
* @param options optional. See MoveOptions.
|
||
*/
|
||
function mv(source, dest, options = {}) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if (yield ioUtil.exists(dest)) {
|
||
let destExists = true;
|
||
if (yield ioUtil.isDirectory(dest)) {
|
||
// If dest is directory copy src into dest
|
||
dest = path.join(dest, path.basename(source));
|
||
destExists = yield ioUtil.exists(dest);
|
||
}
|
||
if (destExists) {
|
||
if (options.force == null || options.force) {
|
||
yield rmRF(dest);
|
||
}
|
||
else {
|
||
throw new Error('Destination already exists');
|
||
}
|
||
}
|
||
}
|
||
yield mkdirP(path.dirname(dest));
|
||
yield ioUtil.rename(source, dest);
|
||
});
|
||
}
|
||
exports.mv = mv;
|
||
/**
|
||
* Remove a path recursively with force
|
||
*
|
||
* @param inputPath path to remove
|
||
*/
|
||
function rmRF(inputPath) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if (ioUtil.IS_WINDOWS) {
|
||
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
|
||
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
|
||
// Check for invalid characters
|
||
// https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file
|
||
if (/[*"<>|]/.test(inputPath)) {
|
||
throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows');
|
||
}
|
||
try {
|
||
const cmdPath = ioUtil.getCmdPath();
|
||
if (yield ioUtil.isDirectory(inputPath, true)) {
|
||
yield exec(`${cmdPath} /s /c "rd /s /q "%inputPath%""`, {
|
||
env: { inputPath }
|
||
});
|
||
}
|
||
else {
|
||
yield exec(`${cmdPath} /s /c "del /f /a "%inputPath%""`, {
|
||
env: { inputPath }
|
||
});
|
||
}
|
||
}
|
||
catch (err) {
|
||
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
// other errors are valid
|
||
if (err.code !== 'ENOENT')
|
||
throw err;
|
||
}
|
||
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
|
||
try {
|
||
yield ioUtil.unlink(inputPath);
|
||
}
|
||
catch (err) {
|
||
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
// other errors are valid
|
||
if (err.code !== 'ENOENT')
|
||
throw err;
|
||
}
|
||
}
|
||
else {
|
||
let isDir = false;
|
||
try {
|
||
isDir = yield ioUtil.isDirectory(inputPath);
|
||
}
|
||
catch (err) {
|
||
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
// other errors are valid
|
||
if (err.code !== 'ENOENT')
|
||
throw err;
|
||
return;
|
||
}
|
||
if (isDir) {
|
||
yield execFile(`rm`, [`-rf`, `${inputPath}`]);
|
||
}
|
||
else {
|
||
yield ioUtil.unlink(inputPath);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
exports.rmRF = rmRF;
|
||
/**
|
||
* Make a directory. Creates the full path with folders in between
|
||
* Will throw if it fails
|
||
*
|
||
* @param fsPath path to create
|
||
* @returns Promise<void>
|
||
*/
|
||
function mkdirP(fsPath) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
assert_1.ok(fsPath, 'a path argument must be provided');
|
||
yield ioUtil.mkdir(fsPath, { recursive: true });
|
||
});
|
||
}
|
||
exports.mkdirP = mkdirP;
|
||
/**
|
||
* Returns path of a tool had the tool actually been invoked. Resolves via paths.
|
||
* If you check and the tool does not exist, it will throw.
|
||
*
|
||
* @param tool name of the tool
|
||
* @param check whether to check if tool exists
|
||
* @returns Promise<string> path to tool
|
||
*/
|
||
function which(tool, check) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if (!tool) {
|
||
throw new Error("parameter 'tool' is required");
|
||
}
|
||
// recursive when check=true
|
||
if (check) {
|
||
const result = yield which(tool, false);
|
||
if (!result) {
|
||
if (ioUtil.IS_WINDOWS) {
|
||
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
|
||
}
|
||
else {
|
||
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
const matches = yield findInPath(tool);
|
||
if (matches && matches.length > 0) {
|
||
return matches[0];
|
||
}
|
||
return '';
|
||
});
|
||
}
|
||
exports.which = which;
|
||
/**
|
||
* Returns a list of all occurrences of the given tool on the system path.
|
||
*
|
||
* @returns Promise<string[]> the paths of the tool
|
||
*/
|
||
function findInPath(tool) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if (!tool) {
|
||
throw new Error("parameter 'tool' is required");
|
||
}
|
||
// build the list of extensions to try
|
||
const extensions = [];
|
||
if (ioUtil.IS_WINDOWS && process.env['PATHEXT']) {
|
||
for (const extension of process.env['PATHEXT'].split(path.delimiter)) {
|
||
if (extension) {
|
||
extensions.push(extension);
|
||
}
|
||
}
|
||
}
|
||
// if it's rooted, return it if exists. otherwise return empty.
|
||
if (ioUtil.isRooted(tool)) {
|
||
const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
|
||
if (filePath) {
|
||
return [filePath];
|
||
}
|
||
return [];
|
||
}
|
||
// if any path separators, return empty
|
||
if (tool.includes(path.sep)) {
|
||
return [];
|
||
}
|
||
// build the list of directories
|
||
//
|
||
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
|
||
// it feels like we should not do this. Checking the current directory seems like more of a use
|
||
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
|
||
// across platforms.
|
||
const directories = [];
|
||
if (process.env.PATH) {
|
||
for (const p of process.env.PATH.split(path.delimiter)) {
|
||
if (p) {
|
||
directories.push(p);
|
||
}
|
||
}
|
||
}
|
||
// find all matches
|
||
const matches = [];
|
||
for (const directory of directories) {
|
||
const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions);
|
||
if (filePath) {
|
||
matches.push(filePath);
|
||
}
|
||
}
|
||
return matches;
|
||
});
|
||
}
|
||
exports.findInPath = findInPath;
|
||
function readCopyOptions(options) {
|
||
const force = options.force == null ? true : options.force;
|
||
const recursive = Boolean(options.recursive);
|
||
const copySourceDirectory = options.copySourceDirectory == null
|
||
? true
|
||
: Boolean(options.copySourceDirectory);
|
||
return { force, recursive, copySourceDirectory };
|
||
}
|
||
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
// Ensure there is not a run away recursive copy
|
||
if (currentDepth >= 255)
|
||
return;
|
||
currentDepth++;
|
||
yield mkdirP(destDir);
|
||
const files = yield ioUtil.readdir(sourceDir);
|
||
for (const fileName of files) {
|
||
const srcFile = `${sourceDir}/${fileName}`;
|
||
const destFile = `${destDir}/${fileName}`;
|
||
const srcFileStat = yield ioUtil.lstat(srcFile);
|
||
if (srcFileStat.isDirectory()) {
|
||
// Recurse
|
||
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
|
||
}
|
||
else {
|
||
yield copyFile(srcFile, destFile, force);
|
||
}
|
||
}
|
||
// Change the mode for the newly created directory
|
||
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
|
||
});
|
||
}
|
||
// Buffered file copy
|
||
function copyFile(srcFile, destFile, force) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
|
||
// unlink/re-link it
|
||
try {
|
||
yield ioUtil.lstat(destFile);
|
||
yield ioUtil.unlink(destFile);
|
||
}
|
||
catch (e) {
|
||
// Try to override file permission
|
||
if (e.code === 'EPERM') {
|
||
yield ioUtil.chmod(destFile, '0666');
|
||
yield ioUtil.unlink(destFile);
|
||
}
|
||
// other errors = it doesn't exist, no work to do
|
||
}
|
||
// Copy over symlink
|
||
const symlinkFull = yield ioUtil.readlink(srcFile);
|
||
yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
|
||
}
|
||
else if (!(yield ioUtil.exists(destFile)) || force) {
|
||
yield ioUtil.copyFile(srcFile, destFile);
|
||
}
|
||
});
|
||
}
|
||
//# sourceMappingURL=io.js.map
|
||
|
||
/***/ }),
|
||
/* 2 */,
|
||
/* 3 */,
|
||
/* 4 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
var _default = '00000000-0000-0000-0000-000000000000';
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 5 */,
|
||
/* 6 */,
|
||
/* 7 */,
|
||
/* 8 */,
|
||
/* 9 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.argStringToArray = exports.ToolRunner = void 0;
|
||
const os = __importStar(__webpack_require__(87));
|
||
const events = __importStar(__webpack_require__(614));
|
||
const child = __importStar(__webpack_require__(129));
|
||
const path = __importStar(__webpack_require__(622));
|
||
const io = __importStar(__webpack_require__(1));
|
||
const ioUtil = __importStar(__webpack_require__(672));
|
||
const timers_1 = __webpack_require__(213);
|
||
/* eslint-disable @typescript-eslint/unbound-method */
|
||
const IS_WINDOWS = process.platform === 'win32';
|
||
/*
|
||
* Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
|
||
*/
|
||
class ToolRunner extends events.EventEmitter {
|
||
constructor(toolPath, args, options) {
|
||
super();
|
||
if (!toolPath) {
|
||
throw new Error("Parameter 'toolPath' cannot be null or empty.");
|
||
}
|
||
this.toolPath = toolPath;
|
||
this.args = args || [];
|
||
this.options = options || {};
|
||
}
|
||
_debug(message) {
|
||
if (this.options.listeners && this.options.listeners.debug) {
|
||
this.options.listeners.debug(message);
|
||
}
|
||
}
|
||
_getCommandString(options, noPrefix) {
|
||
const toolPath = this._getSpawnFileName();
|
||
const args = this._getSpawnArgs(options);
|
||
let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
|
||
if (IS_WINDOWS) {
|
||
// Windows + cmd file
|
||
if (this._isCmdFile()) {
|
||
cmd += toolPath;
|
||
for (const a of args) {
|
||
cmd += ` ${a}`;
|
||
}
|
||
}
|
||
// Windows + verbatim
|
||
else if (options.windowsVerbatimArguments) {
|
||
cmd += `"${toolPath}"`;
|
||
for (const a of args) {
|
||
cmd += ` ${a}`;
|
||
}
|
||
}
|
||
// Windows (regular)
|
||
else {
|
||
cmd += this._windowsQuoteCmdArg(toolPath);
|
||
for (const a of args) {
|
||
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
// OSX/Linux - this can likely be improved with some form of quoting.
|
||
// creating processes on Unix is fundamentally different than Windows.
|
||
// on Unix, execvp() takes an arg array.
|
||
cmd += toolPath;
|
||
for (const a of args) {
|
||
cmd += ` ${a}`;
|
||
}
|
||
}
|
||
return cmd;
|
||
}
|
||
_processLineBuffer(data, strBuffer, onLine) {
|
||
try {
|
||
let s = strBuffer + data.toString();
|
||
let n = s.indexOf(os.EOL);
|
||
while (n > -1) {
|
||
const line = s.substring(0, n);
|
||
onLine(line);
|
||
// the rest of the string ...
|
||
s = s.substring(n + os.EOL.length);
|
||
n = s.indexOf(os.EOL);
|
||
}
|
||
return s;
|
||
}
|
||
catch (err) {
|
||
// streaming lines to console is best effort. Don't fail a build.
|
||
this._debug(`error processing line. Failed with error ${err}`);
|
||
return '';
|
||
}
|
||
}
|
||
_getSpawnFileName() {
|
||
if (IS_WINDOWS) {
|
||
if (this._isCmdFile()) {
|
||
return process.env['COMSPEC'] || 'cmd.exe';
|
||
}
|
||
}
|
||
return this.toolPath;
|
||
}
|
||
_getSpawnArgs(options) {
|
||
if (IS_WINDOWS) {
|
||
if (this._isCmdFile()) {
|
||
let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
|
||
for (const a of this.args) {
|
||
argline += ' ';
|
||
argline += options.windowsVerbatimArguments
|
||
? a
|
||
: this._windowsQuoteCmdArg(a);
|
||
}
|
||
argline += '"';
|
||
return [argline];
|
||
}
|
||
}
|
||
return this.args;
|
||
}
|
||
_endsWith(str, end) {
|
||
return str.endsWith(end);
|
||
}
|
||
_isCmdFile() {
|
||
const upperToolPath = this.toolPath.toUpperCase();
|
||
return (this._endsWith(upperToolPath, '.CMD') ||
|
||
this._endsWith(upperToolPath, '.BAT'));
|
||
}
|
||
_windowsQuoteCmdArg(arg) {
|
||
// for .exe, apply the normal quoting rules that libuv applies
|
||
if (!this._isCmdFile()) {
|
||
return this._uvQuoteCmdArg(arg);
|
||
}
|
||
// otherwise apply quoting rules specific to the cmd.exe command line parser.
|
||
// the libuv rules are generic and are not designed specifically for cmd.exe
|
||
// command line parser.
|
||
//
|
||
// for a detailed description of the cmd.exe command line parser, refer to
|
||
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
|
||
// need quotes for empty arg
|
||
if (!arg) {
|
||
return '""';
|
||
}
|
||
// determine whether the arg needs to be quoted
|
||
const cmdSpecialChars = [
|
||
' ',
|
||
'\t',
|
||
'&',
|
||
'(',
|
||
')',
|
||
'[',
|
||
']',
|
||
'{',
|
||
'}',
|
||
'^',
|
||
'=',
|
||
';',
|
||
'!',
|
||
"'",
|
||
'+',
|
||
',',
|
||
'`',
|
||
'~',
|
||
'|',
|
||
'<',
|
||
'>',
|
||
'"'
|
||
];
|
||
let needsQuotes = false;
|
||
for (const char of arg) {
|
||
if (cmdSpecialChars.some(x => x === char)) {
|
||
needsQuotes = true;
|
||
break;
|
||
}
|
||
}
|
||
// short-circuit if quotes not needed
|
||
if (!needsQuotes) {
|
||
return arg;
|
||
}
|
||
// the following quoting rules are very similar to the rules that by libuv applies.
|
||
//
|
||
// 1) wrap the string in quotes
|
||
//
|
||
// 2) double-up quotes - i.e. " => ""
|
||
//
|
||
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
|
||
// doesn't work well with a cmd.exe command line.
|
||
//
|
||
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
|
||
// for example, the command line:
|
||
// foo.exe "myarg:""my val"""
|
||
// is parsed by a .NET console app into an arg array:
|
||
// [ "myarg:\"my val\"" ]
|
||
// which is the same end result when applying libuv quoting rules. although the actual
|
||
// command line from libuv quoting rules would look like:
|
||
// foo.exe "myarg:\"my val\""
|
||
//
|
||
// 3) double-up slashes that precede a quote,
|
||
// e.g. hello \world => "hello \world"
|
||
// hello\"world => "hello\\""world"
|
||
// hello\\"world => "hello\\\\""world"
|
||
// hello world\ => "hello world\\"
|
||
//
|
||
// technically this is not required for a cmd.exe command line, or the batch argument parser.
|
||
// the reasons for including this as a .cmd quoting rule are:
|
||
//
|
||
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
|
||
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
|
||
//
|
||
// b) it's what we've been doing previously (by deferring to node default behavior) and we
|
||
// haven't heard any complaints about that aspect.
|
||
//
|
||
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
|
||
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
|
||
// by using %%.
|
||
//
|
||
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
|
||
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
|
||
//
|
||
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
|
||
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
|
||
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
|
||
// to an external program.
|
||
//
|
||
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
|
||
// % can be escaped within a .cmd file.
|
||
let reverse = '"';
|
||
let quoteHit = true;
|
||
for (let i = arg.length; i > 0; i--) {
|
||
// walk the string in reverse
|
||
reverse += arg[i - 1];
|
||
if (quoteHit && arg[i - 1] === '\\') {
|
||
reverse += '\\'; // double the slash
|
||
}
|
||
else if (arg[i - 1] === '"') {
|
||
quoteHit = true;
|
||
reverse += '"'; // double the quote
|
||
}
|
||
else {
|
||
quoteHit = false;
|
||
}
|
||
}
|
||
reverse += '"';
|
||
return reverse
|
||
.split('')
|
||
.reverse()
|
||
.join('');
|
||
}
|
||
_uvQuoteCmdArg(arg) {
|
||
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
|
||
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
|
||
// is used.
|
||
//
|
||
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
|
||
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
|
||
// pasting copyright notice from Node within this function:
|
||
//
|
||
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
// of this software and associated documentation files (the "Software"), to
|
||
// deal in the Software without restriction, including without limitation the
|
||
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||
// sell copies of the Software, and to permit persons to whom the Software is
|
||
// furnished to do so, subject to the following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included in
|
||
// all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||
// IN THE SOFTWARE.
|
||
if (!arg) {
|
||
// Need double quotation for empty argument
|
||
return '""';
|
||
}
|
||
if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
|
||
// No quotation needed
|
||
return arg;
|
||
}
|
||
if (!arg.includes('"') && !arg.includes('\\')) {
|
||
// No embedded double quotes or backslashes, so I can just wrap
|
||
// quote marks around the whole thing.
|
||
return `"${arg}"`;
|
||
}
|
||
// Expected input/output:
|
||
// input : hello"world
|
||
// output: "hello\"world"
|
||
// input : hello""world
|
||
// output: "hello\"\"world"
|
||
// input : hello\world
|
||
// output: hello\world
|
||
// input : hello\\world
|
||
// output: hello\\world
|
||
// input : hello\"world
|
||
// output: "hello\\\"world"
|
||
// input : hello\\"world
|
||
// output: "hello\\\\\"world"
|
||
// input : hello world\
|
||
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
|
||
// but it appears the comment is wrong, it should be "hello world\\"
|
||
let reverse = '"';
|
||
let quoteHit = true;
|
||
for (let i = arg.length; i > 0; i--) {
|
||
// walk the string in reverse
|
||
reverse += arg[i - 1];
|
||
if (quoteHit && arg[i - 1] === '\\') {
|
||
reverse += '\\';
|
||
}
|
||
else if (arg[i - 1] === '"') {
|
||
quoteHit = true;
|
||
reverse += '\\';
|
||
}
|
||
else {
|
||
quoteHit = false;
|
||
}
|
||
}
|
||
reverse += '"';
|
||
return reverse
|
||
.split('')
|
||
.reverse()
|
||
.join('');
|
||
}
|
||
_cloneExecOptions(options) {
|
||
options = options || {};
|
||
const result = {
|
||
cwd: options.cwd || process.cwd(),
|
||
env: options.env || process.env,
|
||
silent: options.silent || false,
|
||
windowsVerbatimArguments: options.windowsVerbatimArguments || false,
|
||
failOnStdErr: options.failOnStdErr || false,
|
||
ignoreReturnCode: options.ignoreReturnCode || false,
|
||
delay: options.delay || 10000
|
||
};
|
||
result.outStream = options.outStream || process.stdout;
|
||
result.errStream = options.errStream || process.stderr;
|
||
return result;
|
||
}
|
||
_getSpawnOptions(options, toolPath) {
|
||
options = options || {};
|
||
const result = {};
|
||
result.cwd = options.cwd;
|
||
result.env = options.env;
|
||
result['windowsVerbatimArguments'] =
|
||
options.windowsVerbatimArguments || this._isCmdFile();
|
||
if (options.windowsVerbatimArguments) {
|
||
result.argv0 = `"${toolPath}"`;
|
||
}
|
||
return result;
|
||
}
|
||
/**
|
||
* Exec a tool.
|
||
* Output will be streamed to the live console.
|
||
* Returns promise with return code
|
||
*
|
||
* @param tool path to tool to exec
|
||
* @param options optional exec options. See ExecOptions
|
||
* @returns number
|
||
*/
|
||
exec() {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
// root the tool path if it is unrooted and contains relative pathing
|
||
if (!ioUtil.isRooted(this.toolPath) &&
|
||
(this.toolPath.includes('/') ||
|
||
(IS_WINDOWS && this.toolPath.includes('\\')))) {
|
||
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
|
||
this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
|
||
}
|
||
// if the tool is only a file name, then resolve it from the PATH
|
||
// otherwise verify it exists (add extension on Windows if necessary)
|
||
this.toolPath = yield io.which(this.toolPath, true);
|
||
return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
|
||
this._debug(`exec tool: ${this.toolPath}`);
|
||
this._debug('arguments:');
|
||
for (const arg of this.args) {
|
||
this._debug(` ${arg}`);
|
||
}
|
||
const optionsNonNull = this._cloneExecOptions(this.options);
|
||
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
||
optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
|
||
}
|
||
const state = new ExecState(optionsNonNull, this.toolPath);
|
||
state.on('debug', (message) => {
|
||
this._debug(message);
|
||
});
|
||
if (this.options.cwd && !(yield ioUtil.exists(this.options.cwd))) {
|
||
return reject(new Error(`The cwd: ${this.options.cwd} does not exist!`));
|
||
}
|
||
const fileName = this._getSpawnFileName();
|
||
const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
|
||
let stdbuffer = '';
|
||
if (cp.stdout) {
|
||
cp.stdout.on('data', (data) => {
|
||
if (this.options.listeners && this.options.listeners.stdout) {
|
||
this.options.listeners.stdout(data);
|
||
}
|
||
if (!optionsNonNull.silent && optionsNonNull.outStream) {
|
||
optionsNonNull.outStream.write(data);
|
||
}
|
||
stdbuffer = this._processLineBuffer(data, stdbuffer, (line) => {
|
||
if (this.options.listeners && this.options.listeners.stdline) {
|
||
this.options.listeners.stdline(line);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
let errbuffer = '';
|
||
if (cp.stderr) {
|
||
cp.stderr.on('data', (data) => {
|
||
state.processStderr = true;
|
||
if (this.options.listeners && this.options.listeners.stderr) {
|
||
this.options.listeners.stderr(data);
|
||
}
|
||
if (!optionsNonNull.silent &&
|
||
optionsNonNull.errStream &&
|
||
optionsNonNull.outStream) {
|
||
const s = optionsNonNull.failOnStdErr
|
||
? optionsNonNull.errStream
|
||
: optionsNonNull.outStream;
|
||
s.write(data);
|
||
}
|
||
errbuffer = this._processLineBuffer(data, errbuffer, (line) => {
|
||
if (this.options.listeners && this.options.listeners.errline) {
|
||
this.options.listeners.errline(line);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
cp.on('error', (err) => {
|
||
state.processError = err.message;
|
||
state.processExited = true;
|
||
state.processClosed = true;
|
||
state.CheckComplete();
|
||
});
|
||
cp.on('exit', (code) => {
|
||
state.processExitCode = code;
|
||
state.processExited = true;
|
||
this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
|
||
state.CheckComplete();
|
||
});
|
||
cp.on('close', (code) => {
|
||
state.processExitCode = code;
|
||
state.processExited = true;
|
||
state.processClosed = true;
|
||
this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
|
||
state.CheckComplete();
|
||
});
|
||
state.on('done', (error, exitCode) => {
|
||
if (stdbuffer.length > 0) {
|
||
this.emit('stdline', stdbuffer);
|
||
}
|
||
if (errbuffer.length > 0) {
|
||
this.emit('errline', errbuffer);
|
||
}
|
||
cp.removeAllListeners();
|
||
if (error) {
|
||
reject(error);
|
||
}
|
||
else {
|
||
resolve(exitCode);
|
||
}
|
||
});
|
||
if (this.options.input) {
|
||
if (!cp.stdin) {
|
||
throw new Error('child process missing stdin');
|
||
}
|
||
cp.stdin.end(this.options.input);
|
||
}
|
||
}));
|
||
});
|
||
}
|
||
}
|
||
exports.ToolRunner = ToolRunner;
|
||
/**
|
||
* Convert an arg string to an array of args. Handles escaping
|
||
*
|
||
* @param argString string of arguments
|
||
* @returns string[] array of arguments
|
||
*/
|
||
function argStringToArray(argString) {
|
||
const args = [];
|
||
let inQuotes = false;
|
||
let escaped = false;
|
||
let arg = '';
|
||
function append(c) {
|
||
// we only escape double quotes.
|
||
if (escaped && c !== '"') {
|
||
arg += '\\';
|
||
}
|
||
arg += c;
|
||
escaped = false;
|
||
}
|
||
for (let i = 0; i < argString.length; i++) {
|
||
const c = argString.charAt(i);
|
||
if (c === '"') {
|
||
if (!escaped) {
|
||
inQuotes = !inQuotes;
|
||
}
|
||
else {
|
||
append(c);
|
||
}
|
||
continue;
|
||
}
|
||
if (c === '\\' && escaped) {
|
||
append(c);
|
||
continue;
|
||
}
|
||
if (c === '\\' && inQuotes) {
|
||
escaped = true;
|
||
continue;
|
||
}
|
||
if (c === ' ' && !inQuotes) {
|
||
if (arg.length > 0) {
|
||
args.push(arg);
|
||
arg = '';
|
||
}
|
||
continue;
|
||
}
|
||
append(c);
|
||
}
|
||
if (arg.length > 0) {
|
||
args.push(arg.trim());
|
||
}
|
||
return args;
|
||
}
|
||
exports.argStringToArray = argStringToArray;
|
||
class ExecState extends events.EventEmitter {
|
||
constructor(options, toolPath) {
|
||
super();
|
||
this.processClosed = false; // tracks whether the process has exited and stdio is closed
|
||
this.processError = '';
|
||
this.processExitCode = 0;
|
||
this.processExited = false; // tracks whether the process has exited
|
||
this.processStderr = false; // tracks whether stderr was written to
|
||
this.delay = 10000; // 10 seconds
|
||
this.done = false;
|
||
this.timeout = null;
|
||
if (!toolPath) {
|
||
throw new Error('toolPath must not be empty');
|
||
}
|
||
this.options = options;
|
||
this.toolPath = toolPath;
|
||
if (options.delay) {
|
||
this.delay = options.delay;
|
||
}
|
||
}
|
||
CheckComplete() {
|
||
if (this.done) {
|
||
return;
|
||
}
|
||
if (this.processClosed) {
|
||
this._setResult();
|
||
}
|
||
else if (this.processExited) {
|
||
this.timeout = timers_1.setTimeout(ExecState.HandleTimeout, this.delay, this);
|
||
}
|
||
}
|
||
_debug(message) {
|
||
this.emit('debug', message);
|
||
}
|
||
_setResult() {
|
||
// determine whether there is an error
|
||
let error;
|
||
if (this.processExited) {
|
||
if (this.processError) {
|
||
error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
|
||
}
|
||
else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
|
||
error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
|
||
}
|
||
else if (this.processStderr && this.options.failOnStdErr) {
|
||
error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
|
||
}
|
||
}
|
||
// clear the timeout
|
||
if (this.timeout) {
|
||
clearTimeout(this.timeout);
|
||
this.timeout = null;
|
||
}
|
||
this.done = true;
|
||
this.emit('done', error, this.processExitCode);
|
||
}
|
||
static HandleTimeout(state) {
|
||
if (state.done) {
|
||
return;
|
||
}
|
||
if (!state.processClosed && state.processExited) {
|
||
const message = `The STDIO streams did not close within ${state.delay /
|
||
1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
|
||
state._debug(message);
|
||
}
|
||
state._setResult();
|
||
}
|
||
}
|
||
//# sourceMappingURL=toolrunner.js.map
|
||
|
||
/***/ }),
|
||
/* 10 */,
|
||
/* 11 */,
|
||
/* 12 */,
|
||
/* 13 */,
|
||
/* 14 */,
|
||
/* 15 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
var m = o[Symbol.asyncIterator], i;
|
||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||
};
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const core = __importStar(__webpack_require__(470));
|
||
const exec = __importStar(__webpack_require__(986));
|
||
const glob = __importStar(__webpack_require__(281));
|
||
const io = __importStar(__webpack_require__(1));
|
||
const fs = __importStar(__webpack_require__(747));
|
||
const path = __importStar(__webpack_require__(622));
|
||
const semver = __importStar(__webpack_require__(280));
|
||
const util = __importStar(__webpack_require__(669));
|
||
const uuid_1 = __webpack_require__(898);
|
||
const constants_1 = __webpack_require__(931);
|
||
// From https://github.com/actions/toolkit/blob/main/packages/tool-cache/src/tool-cache.ts#L23
|
||
function createTempDirectory() {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const IS_WINDOWS = process.platform === 'win32';
|
||
let tempDirectory = process.env['RUNNER_TEMP'] || '';
|
||
if (!tempDirectory) {
|
||
let baseLocation;
|
||
if (IS_WINDOWS) {
|
||
// On Windows use the USERPROFILE env variable
|
||
baseLocation = process.env['USERPROFILE'] || 'C:\\';
|
||
}
|
||
else {
|
||
if (process.platform === 'darwin') {
|
||
baseLocation = '/Users';
|
||
}
|
||
else {
|
||
baseLocation = '/home';
|
||
}
|
||
}
|
||
tempDirectory = path.join(baseLocation, 'actions', 'temp');
|
||
}
|
||
const dest = path.join(tempDirectory, uuid_1.v4());
|
||
yield io.mkdirP(dest);
|
||
return dest;
|
||
});
|
||
}
|
||
exports.createTempDirectory = createTempDirectory;
|
||
function getArchiveFileSizeInBytes(filePath) {
|
||
return fs.statSync(filePath).size;
|
||
}
|
||
exports.getArchiveFileSizeInBytes = getArchiveFileSizeInBytes;
|
||
function resolvePaths(patterns) {
|
||
var e_1, _a;
|
||
var _b;
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const paths = [];
|
||
const workspace = (_b = process.env['GITHUB_WORKSPACE']) !== null && _b !== void 0 ? _b : process.cwd();
|
||
const globber = yield glob.create(patterns.join('\n'), {
|
||
implicitDescendants: false
|
||
});
|
||
try {
|
||
for (var _c = __asyncValues(globber.globGenerator()), _d; _d = yield _c.next(), !_d.done;) {
|
||
const file = _d.value;
|
||
const relativeFile = path
|
||
.relative(workspace, file)
|
||
.replace(new RegExp(`\\${path.sep}`, 'g'), '/');
|
||
core.debug(`Matched: ${relativeFile}`);
|
||
// Paths are made relative so the tar entries are all relative to the root of the workspace.
|
||
if (relativeFile === '') {
|
||
// path.relative returns empty string if workspace and file are equal
|
||
paths.push('.');
|
||
}
|
||
else {
|
||
paths.push(`${relativeFile}`);
|
||
}
|
||
}
|
||
}
|
||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
finally {
|
||
try {
|
||
if (_d && !_d.done && (_a = _c.return)) yield _a.call(_c);
|
||
}
|
||
finally { if (e_1) throw e_1.error; }
|
||
}
|
||
return paths;
|
||
});
|
||
}
|
||
exports.resolvePaths = resolvePaths;
|
||
function unlinkFile(filePath) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
return util.promisify(fs.unlink)(filePath);
|
||
});
|
||
}
|
||
exports.unlinkFile = unlinkFile;
|
||
function getVersion(app) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
core.debug(`Checking ${app} --version`);
|
||
let versionOutput = '';
|
||
try {
|
||
yield exec.exec(`${app} --version`, [], {
|
||
ignoreReturnCode: true,
|
||
silent: true,
|
||
listeners: {
|
||
stdout: (data) => (versionOutput += data.toString()),
|
||
stderr: (data) => (versionOutput += data.toString())
|
||
}
|
||
});
|
||
}
|
||
catch (err) {
|
||
core.debug(err.message);
|
||
}
|
||
versionOutput = versionOutput.trim();
|
||
core.debug(versionOutput);
|
||
return versionOutput;
|
||
});
|
||
}
|
||
// Use zstandard if possible to maximize cache performance
|
||
function getCompressionMethod() {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const versionOutput = yield getVersion('zstd');
|
||
const version = semver.clean(versionOutput);
|
||
if (!versionOutput.toLowerCase().includes('zstd command line interface')) {
|
||
// zstd is not installed
|
||
return constants_1.CompressionMethod.Gzip;
|
||
}
|
||
else if (!version || semver.lt(version, 'v1.3.2')) {
|
||
// zstd is installed but using a version earlier than v1.3.2
|
||
// v1.3.2 is required to use the `--long` options in zstd
|
||
return constants_1.CompressionMethod.ZstdWithoutLong;
|
||
}
|
||
else {
|
||
return constants_1.CompressionMethod.Zstd;
|
||
}
|
||
});
|
||
}
|
||
exports.getCompressionMethod = getCompressionMethod;
|
||
function getCacheFileName(compressionMethod) {
|
||
return compressionMethod === constants_1.CompressionMethod.Gzip
|
||
? constants_1.CacheFilename.Gzip
|
||
: constants_1.CacheFilename.Zstd;
|
||
}
|
||
exports.getCacheFileName = getCacheFileName;
|
||
function getGnuTarPathOnWindows() {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
if (fs.existsSync(constants_1.GnuTarPathOnWindows)) {
|
||
return constants_1.GnuTarPathOnWindows;
|
||
}
|
||
const versionOutput = yield getVersion('tar');
|
||
return versionOutput.toLowerCase().includes('gnu tar') ? io.which('tar') : '';
|
||
});
|
||
}
|
||
exports.getGnuTarPathOnWindows = getGnuTarPathOnWindows;
|
||
function assertDefined(name, value) {
|
||
if (value === undefined) {
|
||
throw Error(`Expected ${name} but value was undefiend`);
|
||
}
|
||
return value;
|
||
}
|
||
exports.assertDefined = assertDefined;
|
||
function isGhes() {
|
||
const ghUrl = new URL(process.env['GITHUB_SERVER_URL'] || 'https://github.com');
|
||
return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
|
||
}
|
||
exports.isGhes = isGhes;
|
||
//# sourceMappingURL=cacheUtils.js.map
|
||
|
||
/***/ }),
|
||
/* 16 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("tls");
|
||
|
||
/***/ }),
|
||
/* 17 */,
|
||
/* 18 */
|
||
/***/ (function() {
|
||
|
||
eval("require")("encoding");
|
||
|
||
|
||
/***/ }),
|
||
/* 19 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
var NodeType, XMLDTDNotation, XMLNode,
|
||
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
XMLNode = __webpack_require__(257);
|
||
|
||
NodeType = __webpack_require__(683);
|
||
|
||
module.exports = XMLDTDNotation = (function(superClass) {
|
||
extend(XMLDTDNotation, superClass);
|
||
|
||
function XMLDTDNotation(parent, name, value) {
|
||
XMLDTDNotation.__super__.constructor.call(this, parent);
|
||
if (name == null) {
|
||
throw new Error("Missing DTD notation name. " + this.debugInfo(name));
|
||
}
|
||
if (!value.pubID && !value.sysID) {
|
||
throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
|
||
}
|
||
this.name = this.stringify.name(name);
|
||
this.type = NodeType.NotationDeclaration;
|
||
if (value.pubID != null) {
|
||
this.pubID = this.stringify.dtdPubID(value.pubID);
|
||
}
|
||
if (value.sysID != null) {
|
||
this.sysID = this.stringify.dtdSysID(value.sysID);
|
||
}
|
||
}
|
||
|
||
Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
|
||
get: function() {
|
||
return this.pubID;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
|
||
get: function() {
|
||
return this.sysID;
|
||
}
|
||
});
|
||
|
||
XMLDTDNotation.prototype.toString = function(options) {
|
||
return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
|
||
};
|
||
|
||
return XMLDTDNotation;
|
||
|
||
})(XMLNode);
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 20 */,
|
||
/* 21 */,
|
||
/* 22 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.PropagationAPI = void 0;
|
||
var global_utils_1 = __webpack_require__(94);
|
||
var NoopTextMapPropagator_1 = __webpack_require__(918);
|
||
var TextMapPropagator_1 = __webpack_require__(881);
|
||
var context_helpers_1 = __webpack_require__(483);
|
||
var utils_1 = __webpack_require__(112);
|
||
var diag_1 = __webpack_require__(118);
|
||
var API_NAME = 'propagation';
|
||
var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
|
||
/**
|
||
* Singleton object which represents the entry point to the OpenTelemetry Propagation API
|
||
*/
|
||
var PropagationAPI = /** @class */ (function () {
|
||
/** Empty private constructor prevents end users from constructing a new instance of the API */
|
||
function PropagationAPI() {
|
||
this.createBaggage = utils_1.createBaggage;
|
||
this.getBaggage = context_helpers_1.getBaggage;
|
||
this.setBaggage = context_helpers_1.setBaggage;
|
||
this.deleteBaggage = context_helpers_1.deleteBaggage;
|
||
}
|
||
/** Get the singleton instance of the Propagator API */
|
||
PropagationAPI.getInstance = function () {
|
||
if (!this._instance) {
|
||
this._instance = new PropagationAPI();
|
||
}
|
||
return this._instance;
|
||
};
|
||
/**
|
||
* Set the current propagator.
|
||
*
|
||
* @returns true if the propagator was successfully registered, else false
|
||
*/
|
||
PropagationAPI.prototype.setGlobalPropagator = function (propagator) {
|
||
return global_utils_1.registerGlobal(API_NAME, propagator, diag_1.DiagAPI.instance());
|
||
};
|
||
/**
|
||
* Inject context into a carrier to be propagated inter-process
|
||
*
|
||
* @param context Context carrying tracing data to inject
|
||
* @param carrier carrier to inject context into
|
||
* @param setter Function used to set values on the carrier
|
||
*/
|
||
PropagationAPI.prototype.inject = function (context, carrier, setter) {
|
||
if (setter === void 0) { setter = TextMapPropagator_1.defaultTextMapSetter; }
|
||
return this._getGlobalPropagator().inject(context, carrier, setter);
|
||
};
|
||
/**
|
||
* Extract context from a carrier
|
||
*
|
||
* @param context Context which the newly created context will inherit from
|
||
* @param carrier Carrier to extract context from
|
||
* @param getter Function used to extract keys from a carrier
|
||
*/
|
||
PropagationAPI.prototype.extract = function (context, carrier, getter) {
|
||
if (getter === void 0) { getter = TextMapPropagator_1.defaultTextMapGetter; }
|
||
return this._getGlobalPropagator().extract(context, carrier, getter);
|
||
};
|
||
/**
|
||
* Return a list of all fields which may be used by the propagator.
|
||
*/
|
||
PropagationAPI.prototype.fields = function () {
|
||
return this._getGlobalPropagator().fields();
|
||
};
|
||
/** Remove the global propagator */
|
||
PropagationAPI.prototype.disable = function () {
|
||
global_utils_1.unregisterGlobal(API_NAME, diag_1.DiagAPI.instance());
|
||
};
|
||
PropagationAPI.prototype._getGlobalPropagator = function () {
|
||
return global_utils_1.getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
|
||
};
|
||
return PropagationAPI;
|
||
}());
|
||
exports.PropagationAPI = PropagationAPI;
|
||
//# sourceMappingURL=propagation.js.map
|
||
|
||
/***/ }),
|
||
/* 23 */,
|
||
/* 24 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
var _default = '00000000-0000-0000-0000-000000000000';
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 25 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
Object.defineProperty(exports, "v1", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _v.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "v3", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _v2.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "v4", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _v3.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "v5", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _v4.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "NIL", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _nil.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "version", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _version.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "validate", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _validate.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "stringify", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _stringify.default;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "parse", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _parse.default;
|
||
}
|
||
});
|
||
|
||
var _v = _interopRequireDefault(__webpack_require__(810));
|
||
|
||
var _v2 = _interopRequireDefault(__webpack_require__(572));
|
||
|
||
var _v3 = _interopRequireDefault(__webpack_require__(293));
|
||
|
||
var _v4 = _interopRequireDefault(__webpack_require__(638));
|
||
|
||
var _nil = _interopRequireDefault(__webpack_require__(4));
|
||
|
||
var _version = _interopRequireDefault(__webpack_require__(135));
|
||
|
||
var _validate = _interopRequireDefault(__webpack_require__(634));
|
||
|
||
var _stringify = _interopRequireDefault(__webpack_require__(960));
|
||
|
||
var _parse = _interopRequireDefault(__webpack_require__(204));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/***/ }),
|
||
/* 26 */,
|
||
/* 27 */,
|
||
/* 28 */,
|
||
/* 29 */,
|
||
/* 30 */,
|
||
/* 31 */,
|
||
/* 32 */,
|
||
/* 33 */,
|
||
/* 34 */,
|
||
/* 35 */,
|
||
/* 36 */,
|
||
/* 37 */,
|
||
/* 38 */,
|
||
/* 39 */,
|
||
/* 40 */,
|
||
/* 41 */,
|
||
/* 42 */,
|
||
/* 43 */,
|
||
/* 44 */,
|
||
/* 45 */,
|
||
/* 46 */,
|
||
/* 47 */,
|
||
/* 48 */,
|
||
/* 49 */,
|
||
/* 50 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = ["ac","com.ac","edu.ac","gov.ac","net.ac","mil.ac","org.ac","ad","nom.ad","ae","co.ae","net.ae","org.ae","sch.ae","ac.ae","gov.ae","mil.ae","aero","accident-investigation.aero","accident-prevention.aero","aerobatic.aero","aeroclub.aero","aerodrome.aero","agents.aero","aircraft.aero","airline.aero","airport.aero","air-surveillance.aero","airtraffic.aero","air-traffic-control.aero","ambulance.aero","amusement.aero","association.aero","author.aero","ballooning.aero","broker.aero","caa.aero","cargo.aero","catering.aero","certification.aero","championship.aero","charter.aero","civilaviation.aero","club.aero","conference.aero","consultant.aero","consulting.aero","control.aero","council.aero","crew.aero","design.aero","dgca.aero","educator.aero","emergency.aero","engine.aero","engineer.aero","entertainment.aero","equipment.aero","exchange.aero","express.aero","federation.aero","flight.aero","freight.aero","fuel.aero","gliding.aero","government.aero","groundhandling.aero","group.aero","hanggliding.aero","homebuilt.aero","insurance.aero","journal.aero","journalist.aero","leasing.aero","logistics.aero","magazine.aero","maintenance.aero","media.aero","microlight.aero","modelling.aero","navigation.aero","parachuting.aero","paragliding.aero","passenger-association.aero","pilot.aero","press.aero","production.aero","recreation.aero","repbody.aero","res.aero","research.aero","rotorcraft.aero","safety.aero","scientist.aero","services.aero","show.aero","skydiving.aero","software.aero","student.aero","trader.aero","trading.aero","trainer.aero","union.aero","workinggroup.aero","works.aero","af","gov.af","com.af","org.af","net.af","edu.af","ag","com.ag","org.ag","net.ag","co.ag","nom.ag","ai","off.ai","com.ai","net.ai","org.ai","al","com.al","edu.al","gov.al","mil.al","net.al","org.al","am","co.am","com.am","commune.am","net.am","org.am","ao","ed.ao","gv.ao","og.ao","co.ao","pb.ao","it.ao","aq","ar","com.ar","edu.ar","gob.ar","gov.ar","int.ar","mil.ar","musica.ar","net.ar","org.ar","tur.ar","arpa","e164.arpa","in-addr.arpa","ip6.arpa","iris.arpa","uri.arpa","urn.arpa","as","gov.as","asia","at","ac.at","co.at","gv.at","or.at","au","com.au","net.au","org.au","edu.au","gov.au","asn.au","id.au","info.au","conf.au","oz.au","act.au","nsw.au","nt.au","qld.au","sa.au","tas.au","vic.au","wa.au","act.edu.au","catholic.edu.au","nsw.edu.au","nt.edu.au","qld.edu.au","sa.edu.au","tas.edu.au","vic.edu.au","wa.edu.au","qld.gov.au","sa.gov.au","tas.gov.au","vic.gov.au","wa.gov.au","education.tas.edu.au","schools.nsw.edu.au","aw","com.aw","ax","az","com.az","net.az","int.az","gov.az","org.az","edu.az","info.az","pp.az","mil.az","name.az","pro.az","biz.az","ba","com.ba","edu.ba","gov.ba","mil.ba","net.ba","org.ba","bb","biz.bb","co.bb","com.bb","edu.bb","gov.bb","info.bb","net.bb","org.bb","store.bb","tv.bb","*.bd","be","ac.be","bf","gov.bf","bg","a.bg","b.bg","c.bg","d.bg","e.bg","f.bg","g.bg","h.bg","i.bg","j.bg","k.bg","l.bg","m.bg","n.bg","o.bg","p.bg","q.bg","r.bg","s.bg","t.bg","u.bg","v.bg","w.bg","x.bg","y.bg","z.bg","0.bg","1.bg","2.bg","3.bg","4.bg","5.bg","6.bg","7.bg","8.bg","9.bg","bh","com.bh","edu.bh","net.bh","org.bh","gov.bh","bi","co.bi","com.bi","edu.bi","or.bi","org.bi","biz","bj","asso.bj","barreau.bj","gouv.bj","bm","com.bm","edu.bm","gov.bm","net.bm","org.bm","bn","com.bn","edu.bn","gov.bn","net.bn","org.bn","bo","com.bo","edu.bo","gob.bo","int.bo","org.bo","net.bo","mil.bo","tv.bo","web.bo","academia.bo","agro.bo","arte.bo","blog.bo","bolivia.bo","ciencia.bo","cooperativa.bo","democracia.bo","deporte.bo","ecologia.bo","economia.bo","empresa.bo","indigena.bo","industria.bo","info.bo","medicina.bo","movimiento.bo","musica.bo","natural.bo","nombre.bo","noticias.bo","patria.bo","politica.bo","profesional.bo","plurinacional.bo","pueblo.bo","revista.bo","salud.bo","tecnologia.bo","tksat.bo","transporte.bo","wiki.bo","br","9guacu.br","abc.br","adm.br","adv.br","agr.br","aju.br","am.br","anani.br","aparecida.br","arq.br","art.br","ato.br","b.br","barueri.br","belem.br","bhz.br","bio.br","blog.br","bmd.br","boavista.br","bsb.br","campinagrande.br","campinas.br","caxias.br","cim.br","cng.br","cnt.br","com.br","contagem.br","coop.br","cri.br","cuiaba.br","curitiba.br","def.br","ecn.br","eco.br","edu.br","emp.br","eng.br","esp.br","etc.br","eti.br","far.br","feira.br","flog.br","floripa.br","fm.br","fnd.br","fortal.br","fot.br","foz.br","fst.br","g12.br","ggf.br","goiania.br","gov.br","ac.gov.br","al.gov.br","am.gov.br","ap.gov.br","ba.gov.br","ce.gov.br","df.gov.br","es.gov.br","go.gov.br","ma.gov.br","mg.gov.br","ms.gov.br","mt.gov.br","pa.gov.br","pb.gov.br","pe.gov.br","pi.gov.br","pr.gov.br","rj.gov.br","rn.gov.br","ro.gov.br","rr.gov.br","rs.gov.br","sc.gov.br","se.gov.br","sp.gov.br","to.gov.br","gru.br","imb.br","ind.br","inf.br","jab.br","jampa.br","jdf.br","joinville.br","jor.br","jus.br","leg.br","lel.br","londrina.br","macapa.br","maceio.br","manaus.br","maringa.br","mat.br","med.br","mil.br","morena.br","mp.br","mus.br","natal.br","net.br","niteroi.br","*.nom.br","not.br","ntr.br","odo.br","ong.br","org.br","osasco.br","palmas.br","poa.br","ppg.br","pro.br","psc.br","psi.br","pvh.br","qsl.br","radio.br","rec.br","recife.br","ribeirao.br","rio.br","riobranco.br","riopreto.br","salvador.br","sampa.br","santamaria.br","santoandre.br","saobernardo.br","saogonca.br","sjc.br","slg.br","slz.br","sorocaba.br","srv.br","taxi.br","tc.br","teo.br","the.br","tmp.br","trd.br","tur.br","tv.br","udi.br","vet.br","vix.br","vlog.br","wiki.br","zlg.br","bs","com.bs","net.bs","org.bs","edu.bs","gov.bs","bt","com.bt","edu.bt","gov.bt","net.bt","org.bt","bv","bw","co.bw","org.bw","by","gov.by","mil.by","com.by","of.by","bz","com.bz","net.bz","org.bz","edu.bz","gov.bz","ca","ab.ca","bc.ca","mb.ca","nb.ca","nf.ca","nl.ca","ns.ca","nt.ca","nu.ca","on.ca","pe.ca","qc.ca","sk.ca","yk.ca","gc.ca","cat","cc","cd","gov.cd","cf","cg","ch","ci","org.ci","or.ci","com.ci","co.ci","edu.ci","ed.ci","ac.ci","net.ci","go.ci","asso.ci","aéroport.ci","int.ci","presse.ci","md.ci","gouv.ci","*.ck","!www.ck","cl","aprendemas.cl","co.cl","gob.cl","gov.cl","mil.cl","cm","co.cm","com.cm","gov.cm","net.cm","cn","ac.cn","com.cn","edu.cn","gov.cn","net.cn","org.cn","mil.cn","公司.cn","网络.cn","網絡.cn","ah.cn","bj.cn","cq.cn","fj.cn","gd.cn","gs.cn","gz.cn","gx.cn","ha.cn","hb.cn","he.cn","hi.cn","hl.cn","hn.cn","jl.cn","js.cn","jx.cn","ln.cn","nm.cn","nx.cn","qh.cn","sc.cn","sd.cn","sh.cn","sn.cn","sx.cn","tj.cn","xj.cn","xz.cn","yn.cn","zj.cn","hk.cn","mo.cn","tw.cn","co","arts.co","com.co","edu.co","firm.co","gov.co","info.co","int.co","mil.co","net.co","nom.co","org.co","rec.co","web.co","com","coop","cr","ac.cr","co.cr","ed.cr","fi.cr","go.cr","or.cr","sa.cr","cu","com.cu","edu.cu","org.cu","net.cu","gov.cu","inf.cu","cv","cw","com.cw","edu.cw","net.cw","org.cw","cx","gov.cx","cy","ac.cy","biz.cy","com.cy","ekloges.cy","gov.cy","ltd.cy","name.cy","net.cy","org.cy","parliament.cy","press.cy","pro.cy","tm.cy","cz","de","dj","dk","dm","com.dm","net.dm","org.dm","edu.dm","gov.dm","do","art.do","com.do","edu.do","gob.do","gov.do","mil.do","net.do","org.do","sld.do","web.do","dz","com.dz","org.dz","net.dz","gov.dz","edu.dz","asso.dz","pol.dz","art.dz","ec","com.ec","info.ec","net.ec","fin.ec","k12.ec","med.ec","pro.ec","org.ec","edu.ec","gov.ec","gob.ec","mil.ec","edu","ee","edu.ee","gov.ee","riik.ee","lib.ee","med.ee","com.ee","pri.ee","aip.ee","org.ee","fie.ee","eg","com.eg","edu.eg","eun.eg","gov.eg","mil.eg","name.eg","net.eg","org.eg","sci.eg","*.er","es","com.es","nom.es","org.es","gob.es","edu.es","et","com.et","gov.et","org.et","edu.et","biz.et","name.et","info.et","net.et","eu","fi","aland.fi","fj","ac.fj","biz.fj","com.fj","gov.fj","info.fj","mil.fj","name.fj","net.fj","org.fj","pro.fj","*.fk","fm","fo","fr","asso.fr","com.fr","gouv.fr","nom.fr","prd.fr","tm.fr","aeroport.fr","avocat.fr","avoues.fr","cci.fr","chambagri.fr","chirurgiens-dentistes.fr","experts-comptables.fr","geometre-expert.fr","greta.fr","huissier-justice.fr","medecin.fr","notaires.fr","pharmacien.fr","port.fr","veterinaire.fr","ga","gb","gd","ge","com.ge","edu.ge","gov.ge","org.ge","mil.ge","net.ge","pvt.ge","gf","gg","co.gg","net.gg","org.gg","gh","com.gh","edu.gh","gov.gh","org.gh","mil.gh","gi","com.gi","ltd.gi","gov.gi","mod.gi","edu.gi","org.gi","gl","co.gl","com.gl","edu.gl","net.gl","org.gl","gm","gn","ac.gn","com.gn","edu.gn","gov.gn","org.gn","net.gn","gov","gp","com.gp","net.gp","mobi.gp","edu.gp","org.gp","asso.gp","gq","gr","com.gr","edu.gr","net.gr","org.gr","gov.gr","gs","gt","com.gt","edu.gt","gob.gt","ind.gt","mil.gt","net.gt","org.gt","gu","com.gu","edu.gu","gov.gu","guam.gu","info.gu","net.gu","org.gu","web.gu","gw","gy","co.gy","com.gy","edu.gy","gov.gy","net.gy","org.gy","hk","com.hk","edu.hk","gov.hk","idv.hk","net.hk","org.hk","公司.hk","教育.hk","敎育.hk","政府.hk","個人.hk","个人.hk","箇人.hk","網络.hk","网络.hk","组織.hk","網絡.hk","网絡.hk","组织.hk","組織.hk","組织.hk","hm","hn","com.hn","edu.hn","org.hn","net.hn","mil.hn","gob.hn","hr","iz.hr","from.hr","name.hr","com.hr","ht","com.ht","shop.ht","firm.ht","info.ht","adult.ht","net.ht","pro.ht","org.ht","med.ht","art.ht","coop.ht","pol.ht","asso.ht","edu.ht","rel.ht","gouv.ht","perso.ht","hu","co.hu","info.hu","org.hu","priv.hu","sport.hu","tm.hu","2000.hu","agrar.hu","bolt.hu","casino.hu","city.hu","erotica.hu","erotika.hu","film.hu","forum.hu","games.hu","hotel.hu","ingatlan.hu","jogasz.hu","konyvelo.hu","lakas.hu","media.hu","news.hu","reklam.hu","sex.hu","shop.hu","suli.hu","szex.hu","tozsde.hu","utazas.hu","video.hu","id","ac.id","biz.id","co.id","desa.id","go.id","mil.id","my.id","net.id","or.id","ponpes.id","sch.id","web.id","ie","gov.ie","il","ac.il","co.il","gov.il","idf.il","k12.il","muni.il","net.il","org.il","im","ac.im","co.im","com.im","ltd.co.im","net.im","org.im","plc.co.im","tt.im","tv.im","in","co.in","firm.in","net.in","org.in","gen.in","ind.in","nic.in","ac.in","edu.in","res.in","gov.in","mil.in","info","int","eu.int","io","com.io","iq","gov.iq","edu.iq","mil.iq","com.iq","org.iq","net.iq","ir","ac.ir","co.ir","gov.ir","id.ir","net.ir","org.ir","sch.ir","ایران.ir","ايران.ir","is","net.is","com.is","edu.is","gov.is","org.is","int.is","it","gov.it","edu.it","abr.it","abruzzo.it","aosta-valley.it","aostavalley.it","bas.it","basilicata.it","cal.it","calabria.it","cam.it","campania.it","emilia-romagna.it","emiliaromagna.it","emr.it","friuli-v-giulia.it","friuli-ve-giulia.it","friuli-vegiulia.it","friuli-venezia-giulia.it","friuli-veneziagiulia.it","friuli-vgiulia.it","friuliv-giulia.it","friulive-giulia.it","friulivegiulia.it","friulivenezia-giulia.it","friuliveneziagiulia.it","friulivgiulia.it","fvg.it","laz.it","lazio.it","lig.it","liguria.it","lom.it","lombardia.it","lombardy.it","lucania.it","mar.it","marche.it","mol.it","molise.it","piedmont.it","piemonte.it","pmn.it","pug.it","puglia.it","sar.it","sardegna.it","sardinia.it","sic.it","sicilia.it","sicily.it","taa.it","tos.it","toscana.it","trentin-sud-tirol.it","trentin-süd-tirol.it","trentin-sudtirol.it","trentin-südtirol.it","trentin-sued-tirol.it","trentin-suedtirol.it","trentino-a-adige.it","trentino-aadige.it","trentino-alto-adige.it","trentino-altoadige.it","trentino-s-tirol.it","trentino-stirol.it","trentino-sud-tirol.it","trentino-süd-tirol.it","trentino-sudtirol.it","trentino-südtirol.it","trentino-sued-tirol.it","trentino-suedtirol.it","trentino.it","trentinoa-adige.it","trentinoaadige.it","trentinoalto-adige.it","trentinoaltoadige.it","trentinos-tirol.it","trentinostirol.it","trentinosud-tirol.it","trentinosüd-tirol.it","trentinosudtirol.it","trentinosüdtirol.it","trentinosued-tirol.it","trentinosuedtirol.it","trentinsud-tirol.it","trentinsüd-tirol.it","trentinsudtirol.it","trentinsüdtirol.it","trentinsued-tirol.it","trentinsuedtirol.it","tuscany.it","umb.it","umbria.it","val-d-aosta.it","val-daosta.it","vald-aosta.it","valdaosta.it","valle-aosta.it","valle-d-aosta.it","valle-daosta.it","valleaosta.it","valled-aosta.it","valledaosta.it","vallee-aoste.it","vallée-aoste.it","vallee-d-aoste.it","vallée-d-aoste.it","valleeaoste.it","valléeaoste.it","valleedaoste.it","valléedaoste.it","vao.it","vda.it","ven.it","veneto.it","ag.it","agrigento.it","al.it","alessandria.it","alto-adige.it","altoadige.it","an.it","ancona.it","andria-barletta-trani.it","andria-trani-barletta.it","andriabarlettatrani.it","andriatranibarletta.it","ao.it","aosta.it","aoste.it","ap.it","aq.it","aquila.it","ar.it","arezzo.it","ascoli-piceno.it","ascolipiceno.it","asti.it","at.it","av.it","avellino.it","ba.it","balsan-sudtirol.it","balsan-südtirol.it","balsan-suedtirol.it","balsan.it","bari.it","barletta-trani-andria.it","barlettatraniandria.it","belluno.it","benevento.it","bergamo.it","bg.it","bi.it","biella.it","bl.it","bn.it","bo.it","bologna.it","bolzano-altoadige.it","bolzano.it","bozen-sudtirol.it","bozen-südtirol.it","bozen-suedtirol.it","bozen.it","br.it","brescia.it","brindisi.it","bs.it","bt.it","bulsan-sudtirol.it","bulsan-südtirol.it","bulsan-suedtirol.it","bulsan.it","bz.it","ca.it","cagliari.it","caltanissetta.it","campidano-medio.it","campidanomedio.it","campobasso.it","carbonia-iglesias.it","carboniaiglesias.it","carrara-massa.it","carraramassa.it","caserta.it","catania.it","catanzaro.it","cb.it","ce.it","cesena-forli.it","cesena-forlì.it","cesenaforli.it","cesenaforlì.it","ch.it","chieti.it","ci.it","cl.it","cn.it","co.it","como.it","cosenza.it","cr.it","cremona.it","crotone.it","cs.it","ct.it","cuneo.it","cz.it","dell-ogliastra.it","dellogliastra.it","en.it","enna.it","fc.it","fe.it","fermo.it","ferrara.it","fg.it","fi.it","firenze.it","florence.it","fm.it","foggia.it","forli-cesena.it","forlì-cesena.it","forlicesena.it","forlìcesena.it","fr.it","frosinone.it","ge.it","genoa.it","genova.it","go.it","gorizia.it","gr.it","grosseto.it","iglesias-carbonia.it","iglesiascarbonia.it","im.it","imperia.it","is.it","isernia.it","kr.it","la-spezia.it","laquila.it","laspezia.it","latina.it","lc.it","le.it","lecce.it","lecco.it","li.it","livorno.it","lo.it","lodi.it","lt.it","lu.it","lucca.it","macerata.it","mantova.it","massa-carrara.it","massacarrara.it","matera.it","mb.it","mc.it","me.it","medio-campidano.it","mediocampidano.it","messina.it","mi.it","milan.it","milano.it","mn.it","mo.it","modena.it","monza-brianza.it","monza-e-della-brianza.it","monza.it","monzabrianza.it","monzaebrianza.it","monzaedellabrianza.it","ms.it","mt.it","na.it","naples.it","napoli.it","no.it","novara.it","nu.it","nuoro.it","og.it","ogliastra.it","olbia-tempio.it","olbiatempio.it","or.it","oristano.it","ot.it","pa.it","padova.it","padua.it","palermo.it","parma.it","pavia.it","pc.it","pd.it","pe.it","perugia.it","pesaro-urbino.it","pesarourbino.it","pescara.it","pg.it","pi.it","piacenza.it","pisa.it","pistoia.it","pn.it","po.it","pordenone.it","potenza.it","pr.it","prato.it","pt.it","pu.it","pv.it","pz.it","ra.it","ragusa.it","ravenna.it","rc.it","re.it","reggio-calabria.it","reggio-emilia.it","reggiocalabria.it","reggioemilia.it","rg.it","ri.it","rieti.it","rimini.it","rm.it","rn.it","ro.it","roma.it","rome.it","rovigo.it","sa.it","salerno.it","sassari.it","savona.it","si.it","siena.it","siracusa.it","so.it","sondrio.it","sp.it","sr.it","ss.it","suedtirol.it","südtirol.it","sv.it","ta.it","taranto.it","te.it","tempio-olbia.it","tempioolbia.it","teramo.it","terni.it","tn.it","to.it","torino.it","tp.it","tr.it","trani-andria-barletta.it","trani-barletta-andria.it","traniandriabarletta.it","tranibarlettaandria.it","trapani.it","trento.it","treviso.it","trieste.it","ts.it","turin.it","tv.it","ud.it","udine.it","urbino-pesaro.it","urbinopesaro.it","va.it","varese.it","vb.it","vc.it","ve.it","venezia.it","venice.it","verbania.it","vercelli.it","verona.it","vi.it","vibo-valentia.it","vibovalentia.it","vicenza.it","viterbo.it","vr.it","vs.it","vt.it","vv.it","je","co.je","net.je","org.je","*.jm","jo","com.jo","org.jo","net.jo","edu.jo","sch.jo","gov.jo","mil.jo","name.jo","jobs","jp","ac.jp","ad.jp","co.jp","ed.jp","go.jp","gr.jp","lg.jp","ne.jp","or.jp","aichi.jp","akita.jp","aomori.jp","chiba.jp","ehime.jp","fukui.jp","fukuoka.jp","fukushima.jp","gifu.jp","gunma.jp","hiroshima.jp","hokkaido.jp","hyogo.jp","ibaraki.jp","ishikawa.jp","iwate.jp","kagawa.jp","kagoshima.jp","kanagawa.jp","kochi.jp","kumamoto.jp","kyoto.jp","mie.jp","miyagi.jp","miyazaki.jp","nagano.jp","nagasaki.jp","nara.jp","niigata.jp","oita.jp","okayama.jp","okinawa.jp","osaka.jp","saga.jp","saitama.jp","shiga.jp","shimane.jp","shizuoka.jp","tochigi.jp","tokushima.jp","tokyo.jp","tottori.jp","toyama.jp","wakayama.jp","yamagata.jp","yamaguchi.jp","yamanashi.jp","栃木.jp","愛知.jp","愛媛.jp","兵庫.jp","熊本.jp","茨城.jp","北海道.jp","千葉.jp","和歌山.jp","長崎.jp","長野.jp","新潟.jp","青森.jp","静岡.jp","東京.jp","石川.jp","埼玉.jp","三重.jp","京都.jp","佐賀.jp","大分.jp","大阪.jp","奈良.jp","宮城.jp","宮崎.jp","富山.jp","山口.jp","山形.jp","山梨.jp","岩手.jp","岐阜.jp","岡山.jp","島根.jp","広島.jp","徳島.jp","沖縄.jp","滋賀.jp","神奈川.jp","福井.jp","福岡.jp","福島.jp","秋田.jp","群馬.jp","香川.jp","高知.jp","鳥取.jp","鹿児島.jp","*.kawasaki.jp","*.kitakyushu.jp","*.kobe.jp","*.nagoya.jp","*.sapporo.jp","*.sendai.jp","*.yokohama.jp","!city.kawasaki.jp","!city.kitakyushu.jp","!city.kobe.jp","!city.nagoya.jp","!city.sapporo.jp","!city.sendai.jp","!city.yokohama.jp","aisai.aichi.jp","ama.aichi.jp","anjo.aichi.jp","asuke.aichi.jp","chiryu.aichi.jp","chita.aichi.jp","fuso.aichi.jp","gamagori.aichi.jp","handa.aichi.jp","hazu.aichi.jp","hekinan.aichi.jp","higashiura.aichi.jp","ichinomiya.aichi.jp","inazawa.aichi.jp","inuyama.aichi.jp","isshiki.aichi.jp","iwakura.aichi.jp","kanie.aichi.jp","kariya.aichi.jp","kasugai.aichi.jp","kira.aichi.jp","kiyosu.aichi.jp","komaki.aichi.jp","konan.aichi.jp","kota.aichi.jp","mihama.aichi.jp","miyoshi.aichi.jp","nishio.aichi.jp","nisshin.aichi.jp","obu.aichi.jp","oguchi.aichi.jp","oharu.aichi.jp","okazaki.aichi.jp","owariasahi.aichi.jp","seto.aichi.jp","shikatsu.aichi.jp","shinshiro.aichi.jp","shitara.aichi.jp","tahara.aichi.jp","takahama.aichi.jp","tobishima.aichi.jp","toei.aichi.jp","togo.aichi.jp","tokai.aichi.jp","tokoname.aichi.jp","toyoake.aichi.jp","toyohashi.aichi.jp","toyokawa.aichi.jp","toyone.aichi.jp","toyota.aichi.jp","tsushima.aichi.jp","yatomi.aichi.jp","akita.akita.jp","daisen.akita.jp","fujisato.akita.jp","gojome.akita.jp","hachirogata.akita.jp","happou.akita.jp","higashinaruse.akita.jp","honjo.akita.jp","honjyo.akita.jp","ikawa.akita.jp","kamikoani.akita.jp","kamioka.akita.jp","katagami.akita.jp","kazuno.akita.jp","kitaakita.akita.jp","kosaka.akita.jp","kyowa.akita.jp","misato.akita.jp","mitane.akita.jp","moriyoshi.akita.jp","nikaho.akita.jp","noshiro.akita.jp","odate.akita.jp","oga.akita.jp","ogata.akita.jp","semboku.akita.jp","yokote.akita.jp","yurihonjo.akita.jp","aomori.aomori.jp","gonohe.aomori.jp","hachinohe.aomori.jp","hashikami.aomori.jp","hiranai.aomori.jp","hirosaki.aomori.jp","itayanagi.aomori.jp","kuroishi.aomori.jp","misawa.aomori.jp","mutsu.aomori.jp","nakadomari.aomori.jp","noheji.aomori.jp","oirase.aomori.jp","owani.aomori.jp","rokunohe.aomori.jp","sannohe.aomori.jp","shichinohe.aomori.jp","shingo.aomori.jp","takko.aomori.jp","towada.aomori.jp","tsugaru.aomori.jp","tsuruta.aomori.jp","abiko.chiba.jp","asahi.chiba.jp","chonan.chiba.jp","chosei.chiba.jp","choshi.chiba.jp","chuo.chiba.jp","funabashi.chiba.jp","futtsu.chiba.jp","hanamigawa.chiba.jp","ichihara.chiba.jp","ichikawa.chiba.jp","ichinomiya.chiba.jp","inzai.chiba.jp","isumi.chiba.jp","kamagaya.chiba.jp","kamogawa.chiba.jp","kashiwa.chiba.jp","katori.chiba.jp","katsuura.chiba.jp","kimitsu.chiba.jp","kisarazu.chiba.jp","kozaki.chiba.jp","kujukuri.chiba.jp","kyonan.chiba.jp","matsudo.chiba.jp","midori.chiba.jp","mihama.chiba.jp","minamiboso.chiba.jp","mobara.chiba.jp","mutsuzawa.chiba.jp","nagara.chiba.jp","nagareyama.chiba.jp","narashino.chiba.jp","narita.chiba.jp","noda.chiba.jp","oamishirasato.chiba.jp","omigawa.chiba.jp","onjuku.chiba.jp","otaki.chiba.jp","sakae.chiba.jp","sakura.chiba.jp","shimofusa.chiba.jp","shirako.chiba.jp","shiroi.chiba.jp","shisui.chiba.jp","sodegaura.chiba.jp","sosa.chiba.jp","tako.chiba.jp","tateyama.chiba.jp","togane.chiba.jp","tohnosho.chiba.jp","tomisato.chiba.jp","urayasu.chiba.jp","yachimata.chiba.jp","yachiyo.chiba.jp","yokaichiba.chiba.jp","yokoshibahikari.chiba.jp","yotsukaido.chiba.jp","ainan.ehime.jp","honai.ehime.jp","ikata.ehime.jp","imabari.ehime.jp","iyo.ehime.jp","kamijima.ehime.jp","kihoku.ehime.jp","kumakogen.ehime.jp","masaki.ehime.jp","matsuno.ehime.jp","matsuyama.ehime.jp","namikata.ehime.jp","niihama.ehime.jp","ozu.ehime.jp","saijo.ehime.jp","seiyo.ehime.jp","shikokuchuo.ehime.jp","tobe.ehime.jp","toon.ehime.jp","uchiko.ehime.jp","uwajima.ehime.jp","yawatahama.ehime.jp","echizen.fukui.jp","eiheiji.fukui.jp","fukui.fukui.jp","ikeda.fukui.jp","katsuyama.fukui.jp","mihama.fukui.jp","minamiechizen.fukui.jp","obama.fukui.jp","ohi.fukui.jp","ono.fukui.jp","sabae.fukui.jp","sakai.fukui.jp","takahama.fukui.jp","tsuruga.fukui.jp","wakasa.fukui.jp","ashiya.fukuoka.jp","buzen.fukuoka.jp","chikugo.fukuoka.jp","chikuho.fukuoka.jp","chikujo.fukuoka.jp","chikushino.fukuoka.jp","chikuzen.fukuoka.jp","chuo.fukuoka.jp","dazaifu.fukuoka.jp","fukuchi.fukuoka.jp","hakata.fukuoka.jp","higashi.fukuoka.jp","hirokawa.fukuoka.jp","hisayama.fukuoka.jp","iizuka.fukuoka.jp","inatsuki.fukuoka.jp","kaho.fukuoka.jp","kasuga.fukuoka.jp","kasuya.fukuoka.jp","kawara.fukuoka.jp","keisen.fukuoka.jp","koga.fukuoka.jp","kurate.fukuoka.jp","kurogi.fukuoka.jp","kurume.fukuoka.jp","minami.fukuoka.jp","miyako.fukuoka.jp","miyama.fukuoka.jp","miyawaka.fukuoka.jp","mizumaki.fukuoka.jp","munakata.fukuoka.jp","nakagawa.fukuoka.jp","nakama.fukuoka.jp","nishi.fukuoka.jp","nogata.fukuoka.jp","ogori.fukuoka.jp","okagaki.fukuoka.jp","okawa.fukuoka.jp","oki.fukuoka.jp","omuta.fukuoka.jp","onga.fukuoka.jp","onojo.fukuoka.jp","oto.fukuoka.jp","saigawa.fukuoka.jp","sasaguri.fukuoka.jp","shingu.fukuoka.jp","shinyoshitomi.fukuoka.jp","shonai.fukuoka.jp","soeda.fukuoka.jp","sue.fukuoka.jp","tachiarai.fukuoka.jp","tagawa.fukuoka.jp","takata.fukuoka.jp","toho.fukuoka.jp","toyotsu.fukuoka.jp","tsuiki.fukuoka.jp","ukiha.fukuoka.jp","umi.fukuoka.jp","usui.fukuoka.jp","yamada.fukuoka.jp","yame.fukuoka.jp","yanagawa.fukuoka.jp","yukuhashi.fukuoka.jp","aizubange.fukushima.jp","aizumisato.fukushima.jp","aizuwakamatsu.fukushima.jp","asakawa.fukushima.jp","bandai.fukushima.jp","date.fukushima.jp","fukushima.fukushima.jp","furudono.fukushima.jp","futaba.fukushima.jp","hanawa.fukushima.jp","higashi.fukushima.jp","hirata.fukushima.jp","hirono.fukushima.jp","iitate.fukushima.jp","inawashiro.fukushima.jp","ishikawa.fukushima.jp","iwaki.fukushima.jp","izumizaki.fukushima.jp","kagamiishi.fukushima.jp","kaneyama.fukushima.jp","kawamata.fukushima.jp","kitakata.fukushima.jp","kitashiobara.fukushima.jp","koori.fukushima.jp","koriyama.fukushima.jp","kunimi.fukushima.jp","miharu.fukushima.jp","mishima.fukushima.jp","namie.fukushima.jp","nango.fukushima.jp","nishiaizu.fukushima.jp","nishigo.fukushima.jp","okuma.fukushima.jp","omotego.fukushima.jp","ono.fukushima.jp","otama.fukushima.jp","samegawa.fukushima.jp","shimogo.fukushima.jp","shirakawa.fukushima.jp","showa.fukushima.jp","soma.fukushima.jp","sukagawa.fukushima.jp","taishin.fukushima.jp","tamakawa.fukushima.jp","tanagura.fukushima.jp","tenei.fukushima.jp","yabuki.fukushima.jp","yamato.fukushima.jp","yamatsuri.fukushima.jp","yanaizu.fukushima.jp","yugawa.fukushima.jp","anpachi.gifu.jp","ena.gifu.jp","gifu.gifu.jp","ginan.gifu.jp","godo.gifu.jp","gujo.gifu.jp","hashima.gifu.jp","hichiso.gifu.jp","hida.gifu.jp","higashishirakawa.gifu.jp","ibigawa.gifu.jp","ikeda.gifu.jp","kakamigahara.gifu.jp","kani.gifu.jp","kasahara.gifu.jp","kasamatsu.gifu.jp","kawaue.gifu.jp","kitagata.gifu.jp","mino.gifu.jp","minokamo.gifu.jp","mitake.gifu.jp","mizunami.gifu.jp","motosu.gifu.jp","nakatsugawa.gifu.jp","ogaki.gifu.jp","sakahogi.gifu.jp","seki.gifu.jp","sekigahara.gifu.jp","shirakawa.gifu.jp","tajimi.gifu.jp","takayama.gifu.jp","tarui.gifu.jp","toki.gifu.jp","tomika.gifu.jp","wanouchi.gifu.jp","yamagata.gifu.jp","yaotsu.gifu.jp","yoro.gifu.jp","annaka.gunma.jp","chiyoda.gunma.jp","fujioka.gunma.jp","higashiagatsuma.gunma.jp","isesaki.gunma.jp","itakura.gunma.jp","kanna.gunma.jp","kanra.gunma.jp","katashina.gunma.jp","kawaba.gunma.jp","kiryu.gunma.jp","kusatsu.gunma.jp","maebashi.gunma.jp","meiwa.gunma.jp","midori.gunma.jp","minakami.gunma.jp","naganohara.gunma.jp","nakanojo.gunma.jp","nanmoku.gunma.jp","numata.gunma.jp","oizumi.gunma.jp","ora.gunma.jp","ota.gunma.jp","shibukawa.gunma.jp","shimonita.gunma.jp","shinto.gunma.jp","showa.gunma.jp","takasaki.gunma.jp","takayama.gunma.jp","tamamura.gunma.jp","tatebayashi.gunma.jp","tomioka.gunma.jp","tsukiyono.gunma.jp","tsumagoi.gunma.jp","ueno.gunma.jp","yoshioka.gunma.jp","asaminami.hiroshima.jp","daiwa.hiroshima.jp","etajima.hiroshima.jp","fuchu.hiroshima.jp","fukuyama.hiroshima.jp","hatsukaichi.hiroshima.jp","higashihiroshima.hiroshima.jp","hongo.hiroshima.jp","jinsekikogen.hiroshima.jp","kaita.hiroshima.jp","kui.hiroshima.jp","kumano.hiroshima.jp","kure.hiroshima.jp","mihara.hiroshima.jp","miyoshi.hiroshima.jp","naka.hiroshima.jp","onomichi.hiroshima.jp","osakikamijima.hiroshima.jp","otake.hiroshima.jp","saka.hiroshima.jp","sera.hiroshima.jp","seranishi.hiroshima.jp","shinichi.hiroshima.jp","shobara.hiroshima.jp","takehara.hiroshima.jp","abashiri.hokkaido.jp","abira.hokkaido.jp","aibetsu.hokkaido.jp","akabira.hokkaido.jp","akkeshi.hokkaido.jp","asahikawa.hokkaido.jp","ashibetsu.hokkaido.jp","ashoro.hokkaido.jp","assabu.hokkaido.jp","atsuma.hokkaido.jp","bibai.hokkaido.jp","biei.hokkaido.jp","bifuka.hokkaido.jp","bihoro.hokkaido.jp","biratori.hokkaido.jp","chippubetsu.hokkaido.jp","chitose.hokkaido.jp","date.hokkaido.jp","ebetsu.hokkaido.jp","embetsu.hokkaido.jp","eniwa.hokkaido.jp","erimo.hokkaido.jp","esan.hokkaido.jp","esashi.hokkaido.jp","fukagawa.hokkaido.jp","fukushima.hokkaido.jp","furano.hokkaido.jp","furubira.hokkaido.jp","haboro.hokkaido.jp","hakodate.hokkaido.jp","hamatonbetsu.hokkaido.jp","hidaka.hokkaido.jp","higashikagura.hokkaido.jp","higashikawa.hokkaido.jp","hiroo.hokkaido.jp","hokuryu.hokkaido.jp","hokuto.hokkaido.jp","honbetsu.hokkaido.jp","horokanai.hokkaido.jp","horonobe.hokkaido.jp","ikeda.hokkaido.jp","imakane.hokkaido.jp","ishikari.hokkaido.jp","iwamizawa.hokkaido.jp","iwanai.hokkaido.jp","kamifurano.hokkaido.jp","kamikawa.hokkaido.jp","kamishihoro.hokkaido.jp","kamisunagawa.hokkaido.jp","kamoenai.hokkaido.jp","kayabe.hokkaido.jp","kembuchi.hokkaido.jp","kikonai.hokkaido.jp","kimobetsu.hokkaido.jp","kitahiroshima.hokkaido.jp","kitami.hokkaido.jp","kiyosato.hokkaido.jp","koshimizu.hokkaido.jp","kunneppu.hokkaido.jp","kuriyama.hokkaido.jp","kuromatsunai.hokkaido.jp","kushiro.hokkaido.jp","kutchan.hokkaido.jp","kyowa.hokkaido.jp","mashike.hokkaido.jp","matsumae.hokkaido.jp","mikasa.hokkaido.jp","minamifurano.hokkaido.jp","mombetsu.hokkaido.jp","moseushi.hokkaido.jp","mukawa.hokkaido.jp","muroran.hokkaido.jp","naie.hokkaido.jp","nakagawa.hokkaido.jp","nakasatsunai.hokkaido.jp","nakatombetsu.hokkaido.jp","nanae.hokkaido.jp","nanporo.hokkaido.jp","nayoro.hokkaido.jp","nemuro.hokkaido.jp","niikappu.hokkaido.jp","niki.hokkaido.jp","nishiokoppe.hokkaido.jp","noboribetsu.hokkaido.jp","numata.hokkaido.jp","obihiro.hokkaido.jp","obira.hokkaido.jp","oketo.hokkaido.jp","okoppe.hokkaido.jp","otaru.hokkaido.jp","otobe.hokkaido.jp","otofuke.hokkaido.jp","otoineppu.hokkaido.jp","oumu.hokkaido.jp","ozora.hokkaido.jp","pippu.hokkaido.jp","rankoshi.hokkaido.jp","rebun.hokkaido.jp","rikubetsu.hokkaido.jp","rishiri.hokkaido.jp","rishirifuji.hokkaido.jp","saroma.hokkaido.jp","sarufutsu.hokkaido.jp","shakotan.hokkaido.jp","shari.hokkaido.jp","shibecha.hokkaido.jp","shibetsu.hokkaido.jp","shikabe.hokkaido.jp","shikaoi.hokkaido.jp","shimamaki.hokkaido.jp","shimizu.hokkaido.jp","shimokawa.hokkaido.jp","shinshinotsu.hokkaido.jp","shintoku.hokkaido.jp","shiranuka.hokkaido.jp","shiraoi.hokkaido.jp","shiriuchi.hokkaido.jp","sobetsu.hokkaido.jp","sunagawa.hokkaido.jp","taiki.hokkaido.jp","takasu.hokkaido.jp","takikawa.hokkaido.jp","takinoue.hokkaido.jp","teshikaga.hokkaido.jp","tobetsu.hokkaido.jp","tohma.hokkaido.jp","tomakomai.hokkaido.jp","tomari.hokkaido.jp","toya.hokkaido.jp","toyako.hokkaido.jp","toyotomi.hokkaido.jp","toyoura.hokkaido.jp","tsubetsu.hokkaido.jp","tsukigata.hokkaido.jp","urakawa.hokkaido.jp","urausu.hokkaido.jp","uryu.hokkaido.jp","utashinai.hokkaido.jp","wakkanai.hokkaido.jp","wassamu.hokkaido.jp","yakumo.hokkaido.jp","yoichi.hokkaido.jp","aioi.hyogo.jp","akashi.hyogo.jp","ako.hyogo.jp","amagasaki.hyogo.jp","aogaki.hyogo.jp","asago.hyogo.jp","ashiya.hyogo.jp","awaji.hyogo.jp","fukusaki.hyogo.jp","goshiki.hyogo.jp","harima.hyogo.jp","himeji.hyogo.jp","ichikawa.hyogo.jp","inagawa.hyogo.jp","itami.hyogo.jp","kakogawa.hyogo.jp","kamigori.hyogo.jp","kamikawa.hyogo.jp","kasai.hyogo.jp","kasuga.hyogo.jp","kawanishi.hyogo.jp","miki.hyogo.jp","minamiawaji.hyogo.jp","nishinomiya.hyogo.jp","nishiwaki.hyogo.jp","ono.hyogo.jp","sanda.hyogo.jp","sannan.hyogo.jp","sasayama.hyogo.jp","sayo.hyogo.jp","shingu.hyogo.jp","shinonsen.hyogo.jp","shiso.hyogo.jp","sumoto.hyogo.jp","taishi.hyogo.jp","taka.hyogo.jp","takarazuka.hyogo.jp","takasago.hyogo.jp","takino.hyogo.jp","tamba.hyogo.jp","tatsuno.hyogo.jp","toyooka.hyogo.jp","yabu.hyogo.jp","yashiro.hyogo.jp","yoka.hyogo.jp","yokawa.hyogo.jp","ami.ibaraki.jp","asahi.ibaraki.jp","bando.ibaraki.jp","chikusei.ibaraki.jp","daigo.ibaraki.jp","fujishiro.ibaraki.jp","hitachi.ibaraki.jp","hitachinaka.ibaraki.jp","hitachiomiya.ibaraki.jp","hitachiota.ibaraki.jp","ibaraki.ibaraki.jp","ina.ibaraki.jp","inashiki.ibaraki.jp","itako.ibaraki.jp","iwama.ibaraki.jp","joso.ibaraki.jp","kamisu.ibaraki.jp","kasama.ibaraki.jp","kashima.ibaraki.jp","kasumigaura.ibaraki.jp","koga.ibaraki.jp","miho.ibaraki.jp","mito.ibaraki.jp","moriya.ibaraki.jp","naka.ibaraki.jp","namegata.ibaraki.jp","oarai.ibaraki.jp","ogawa.ibaraki.jp","omitama.ibaraki.jp","ryugasaki.ibaraki.jp","sakai.ibaraki.jp","sakuragawa.ibaraki.jp","shimodate.ibaraki.jp","shimotsuma.ibaraki.jp","shirosato.ibaraki.jp","sowa.ibaraki.jp","suifu.ibaraki.jp","takahagi.ibaraki.jp","tamatsukuri.ibaraki.jp","tokai.ibaraki.jp","tomobe.ibaraki.jp","tone.ibaraki.jp","toride.ibaraki.jp","tsuchiura.ibaraki.jp","tsukuba.ibaraki.jp","uchihara.ibaraki.jp","ushiku.ibaraki.jp","yachiyo.ibaraki.jp","yamagata.ibaraki.jp","yawara.ibaraki.jp","yuki.ibaraki.jp","anamizu.ishikawa.jp","hakui.ishikawa.jp","hakusan.ishikawa.jp","kaga.ishikawa.jp","kahoku.ishikawa.jp","kanazawa.ishikawa.jp","kawakita.ishikawa.jp","komatsu.ishikawa.jp","nakanoto.ishikawa.jp","nanao.ishikawa.jp","nomi.ishikawa.jp","nonoichi.ishikawa.jp","noto.ishikawa.jp","shika.ishikawa.jp","suzu.ishikawa.jp","tsubata.ishikawa.jp","tsurugi.ishikawa.jp","uchinada.ishikawa.jp","wajima.ishikawa.jp","fudai.iwate.jp","fujisawa.iwate.jp","hanamaki.iwate.jp","hiraizumi.iwate.jp","hirono.iwate.jp","ichinohe.iwate.jp","ichinoseki.iwate.jp","iwaizumi.iwate.jp","iwate.iwate.jp","joboji.iwate.jp","kamaishi.iwate.jp","kanegasaki.iwate.jp","karumai.iwate.jp","kawai.iwate.jp","kitakami.iwate.jp","kuji.iwate.jp","kunohe.iwate.jp","kuzumaki.iwate.jp","miyako.iwate.jp","mizusawa.iwate.jp","morioka.iwate.jp","ninohe.iwate.jp","noda.iwate.jp","ofunato.iwate.jp","oshu.iwate.jp","otsuchi.iwate.jp","rikuzentakata.iwate.jp","shiwa.iwate.jp","shizukuishi.iwate.jp","sumita.iwate.jp","tanohata.iwate.jp","tono.iwate.jp","yahaba.iwate.jp","yamada.iwate.jp","ayagawa.kagawa.jp","higashikagawa.kagawa.jp","kanonji.kagawa.jp","kotohira.kagawa.jp","manno.kagawa.jp","marugame.kagawa.jp","mitoyo.kagawa.jp","naoshima.kagawa.jp","sanuki.kagawa.jp","tadotsu.kagawa.jp","takamatsu.kagawa.jp","tonosho.kagawa.jp","uchinomi.kagawa.jp","utazu.kagawa.jp","zentsuji.kagawa.jp","akune.kagoshima.jp","amami.kagoshima.jp","hioki.kagoshima.jp","isa.kagoshima.jp","isen.kagoshima.jp","izumi.kagoshima.jp","kagoshima.kagoshima.jp","kanoya.kagoshima.jp","kawanabe.kagoshima.jp","kinko.kagoshima.jp","kouyama.kagoshima.jp","makurazaki.kagoshima.jp","matsumoto.kagoshima.jp","minamitane.kagoshima.jp","nakatane.kagoshima.jp","nishinoomote.kagoshima.jp","satsumasendai.kagoshima.jp","soo.kagoshima.jp","tarumizu.kagoshima.jp","yusui.kagoshima.jp","aikawa.kanagawa.jp","atsugi.kanagawa.jp","ayase.kanagawa.jp","chigasaki.kanagawa.jp","ebina.kanagawa.jp","fujisawa.kanagawa.jp","hadano.kanagawa.jp","hakone.kanagawa.jp","hiratsuka.kanagawa.jp","isehara.kanagawa.jp","kaisei.kanagawa.jp","kamakura.kanagawa.jp","kiyokawa.kanagawa.jp","matsuda.kanagawa.jp","minamiashigara.kanagawa.jp","miura.kanagawa.jp","nakai.kanagawa.jp","ninomiya.kanagawa.jp","odawara.kanagawa.jp","oi.kanagawa.jp","oiso.kanagawa.jp","sagamihara.kanagawa.jp","samukawa.kanagawa.jp","tsukui.kanagawa.jp","yamakita.kanagawa.jp","yamato.kanagawa.jp","yokosuka.kanagawa.jp","yugawara.kanagawa.jp","zama.kanagawa.jp","zushi.kanagawa.jp","aki.kochi.jp","geisei.kochi.jp","hidaka.kochi.jp","higashitsuno.kochi.jp","ino.kochi.jp","kagami.kochi.jp","kami.kochi.jp","kitagawa.kochi.jp","kochi.kochi.jp","mihara.kochi.jp","motoyama.kochi.jp","muroto.kochi.jp","nahari.kochi.jp","nakamura.kochi.jp","nankoku.kochi.jp","nishitosa.kochi.jp","niyodogawa.kochi.jp","ochi.kochi.jp","okawa.kochi.jp","otoyo.kochi.jp","otsuki.kochi.jp","sakawa.kochi.jp","sukumo.kochi.jp","susaki.kochi.jp","tosa.kochi.jp","tosashimizu.kochi.jp","toyo.kochi.jp","tsuno.kochi.jp","umaji.kochi.jp","yasuda.kochi.jp","yusuhara.kochi.jp","amakusa.kumamoto.jp","arao.kumamoto.jp","aso.kumamoto.jp","choyo.kumamoto.jp","gyokuto.kumamoto.jp","kamiamakusa.kumamoto.jp","kikuchi.kumamoto.jp","kumamoto.kumamoto.jp","mashiki.kumamoto.jp","mifune.kumamoto.jp","minamata.kumamoto.jp","minamioguni.kumamoto.jp","nagasu.kumamoto.jp","nishihara.kumamoto.jp","oguni.kumamoto.jp","ozu.kumamoto.jp","sumoto.kumamoto.jp","takamori.kumamoto.jp","uki.kumamoto.jp","uto.kumamoto.jp","yamaga.kumamoto.jp","yamato.kumamoto.jp","yatsushiro.kumamoto.jp","ayabe.kyoto.jp","fukuchiyama.kyoto.jp","higashiyama.kyoto.jp","ide.kyoto.jp","ine.kyoto.jp","joyo.kyoto.jp","kameoka.kyoto.jp","kamo.kyoto.jp","kita.kyoto.jp","kizu.kyoto.jp","kumiyama.kyoto.jp","kyotamba.kyoto.jp","kyotanabe.kyoto.jp","kyotango.kyoto.jp","maizuru.kyoto.jp","minami.kyoto.jp","minamiyamashiro.kyoto.jp","miyazu.kyoto.jp","muko.kyoto.jp","nagaokakyo.kyoto.jp","nakagyo.kyoto.jp","nantan.kyoto.jp","oyamazaki.kyoto.jp","sakyo.kyoto.jp","seika.kyoto.jp","tanabe.kyoto.jp","uji.kyoto.jp","ujitawara.kyoto.jp","wazuka.kyoto.jp","yamashina.kyoto.jp","yawata.kyoto.jp","asahi.mie.jp","inabe.mie.jp","ise.mie.jp","kameyama.mie.jp","kawagoe.mie.jp","kiho.mie.jp","kisosaki.mie.jp","kiwa.mie.jp","komono.mie.jp","kumano.mie.jp","kuwana.mie.jp","matsusaka.mie.jp","meiwa.mie.jp","mihama.mie.jp","minamiise.mie.jp","misugi.mie.jp","miyama.mie.jp","nabari.mie.jp","shima.mie.jp","suzuka.mie.jp","tado.mie.jp","taiki.mie.jp","taki.mie.jp","tamaki.mie.jp","toba.mie.jp","tsu.mie.jp","udono.mie.jp","ureshino.mie.jp","watarai.mie.jp","yokkaichi.mie.jp","furukawa.miyagi.jp","higashimatsushima.miyagi.jp","ishinomaki.miyagi.jp","iwanuma.miyagi.jp","kakuda.miyagi.jp","kami.miyagi.jp","kawasaki.miyagi.jp","marumori.miyagi.jp","matsushima.miyagi.jp","minamisanriku.miyagi.jp","misato.miyagi.jp","murata.miyagi.jp","natori.miyagi.jp","ogawara.miyagi.jp","ohira.miyagi.jp","onagawa.miyagi.jp","osaki.miyagi.jp","rifu.miyagi.jp","semine.miyagi.jp","shibata.miyagi.jp","shichikashuku.miyagi.jp","shikama.miyagi.jp","shiogama.miyagi.jp","shiroishi.miyagi.jp","tagajo.miyagi.jp","taiwa.miyagi.jp","tome.miyagi.jp","tomiya.miyagi.jp","wakuya.miyagi.jp","watari.miyagi.jp","yamamoto.miyagi.jp","zao.miyagi.jp","aya.miyazaki.jp","ebino.miyazaki.jp","gokase.miyazaki.jp","hyuga.miyazaki.jp","kadogawa.miyazaki.jp","kawaminami.miyazaki.jp","kijo.miyazaki.jp","kitagawa.miyazaki.jp","kitakata.miyazaki.jp","kitaura.miyazaki.jp","kobayashi.miyazaki.jp","kunitomi.miyazaki.jp","kushima.miyazaki.jp","mimata.miyazaki.jp","miyakonojo.miyazaki.jp","miyazaki.miyazaki.jp","morotsuka.miyazaki.jp","nichinan.miyazaki.jp","nishimera.miyazaki.jp","nobeoka.miyazaki.jp","saito.miyazaki.jp","shiiba.miyazaki.jp","shintomi.miyazaki.jp","takaharu.miyazaki.jp","takanabe.miyazaki.jp","takazaki.miyazaki.jp","tsuno.miyazaki.jp","achi.nagano.jp","agematsu.nagano.jp","anan.nagano.jp","aoki.nagano.jp","asahi.nagano.jp","azumino.nagano.jp","chikuhoku.nagano.jp","chikuma.nagano.jp","chino.nagano.jp","fujimi.nagano.jp","hakuba.nagano.jp","hara.nagano.jp","hiraya.nagano.jp","iida.nagano.jp","iijima.nagano.jp","iiyama.nagano.jp","iizuna.nagano.jp","ikeda.nagano.jp","ikusaka.nagano.jp","ina.nagano.jp","karuizawa.nagano.jp","kawakami.nagano.jp","kiso.nagano.jp","kisofukushima.nagano.jp","kitaaiki.nagano.jp","komagane.nagano.jp","komoro.nagano.jp","matsukawa.nagano.jp","matsumoto.nagano.jp","miasa.nagano.jp","minamiaiki.nagano.jp","minamimaki.nagano.jp","minamiminowa.nagano.jp","minowa.nagano.jp","miyada.nagano.jp","miyota.nagano.jp","mochizuki.nagano.jp","nagano.nagano.jp","nagawa.nagano.jp","nagiso.nagano.jp","nakagawa.nagano.jp","nakano.nagano.jp","nozawaonsen.nagano.jp","obuse.nagano.jp","ogawa.nagano.jp","okaya.nagano.jp","omachi.nagano.jp","omi.nagano.jp","ookuwa.nagano.jp","ooshika.nagano.jp","otaki.nagano.jp","otari.nagano.jp","sakae.nagano.jp","sakaki.nagano.jp","saku.nagano.jp","sakuho.nagano.jp","shimosuwa.nagano.jp","shinanomachi.nagano.jp","shiojiri.nagano.jp","suwa.nagano.jp","suzaka.nagano.jp","takagi.nagano.jp","takamori.nagano.jp","takayama.nagano.jp","tateshina.nagano.jp","tatsuno.nagano.jp","togakushi.nagano.jp","togura.nagano.jp","tomi.nagano.jp","ueda.nagano.jp","wada.nagano.jp","yamagata.nagano.jp","yamanouchi.nagano.jp","yasaka.nagano.jp","yasuoka.nagano.jp","chijiwa.nagasaki.jp","futsu.nagasaki.jp","goto.nagasaki.jp","hasami.nagasaki.jp","hirado.nagasaki.jp","iki.nagasaki.jp","isahaya.nagasaki.jp","kawatana.nagasaki.jp","kuchinotsu.nagasaki.jp","matsuura.nagasaki.jp","nagasaki.nagasaki.jp","obama.nagasaki.jp","omura.nagasaki.jp","oseto.nagasaki.jp","saikai.nagasaki.jp","sasebo.nagasaki.jp","seihi.nagasaki.jp","shimabara.nagasaki.jp","shinkamigoto.nagasaki.jp","togitsu.nagasaki.jp","tsushima.nagasaki.jp","unzen.nagasaki.jp","ando.nara.jp","gose.nara.jp","heguri.nara.jp","higashiyoshino.nara.jp","ikaruga.nara.jp","ikoma.nara.jp","kamikitayama.nara.jp","kanmaki.nara.jp","kashiba.nara.jp","kashihara.nara.jp","katsuragi.nara.jp","kawai.nara.jp","kawakami.nara.jp","kawanishi.nara.jp","koryo.nara.jp","kurotaki.nara.jp","mitsue.nara.jp","miyake.nara.jp","nara.nara.jp","nosegawa.nara.jp","oji.nara.jp","ouda.nara.jp","oyodo.nara.jp","sakurai.nara.jp","sango.nara.jp","shimoichi.nara.jp","shimokitayama.nara.jp","shinjo.nara.jp","soni.nara.jp","takatori.nara.jp","tawaramoto.nara.jp","tenkawa.nara.jp","tenri.nara.jp","uda.nara.jp","yamatokoriyama.nara.jp","yamatotakada.nara.jp","yamazoe.nara.jp","yoshino.nara.jp","aga.niigata.jp","agano.niigata.jp","gosen.niigata.jp","itoigawa.niigata.jp","izumozaki.niigata.jp","joetsu.niigata.jp","kamo.niigata.jp","kariwa.niigata.jp","kashiwazaki.niigata.jp","minamiuonuma.niigata.jp","mitsuke.niigata.jp","muika.niigata.jp","murakami.niigata.jp","myoko.niigata.jp","nagaoka.niigata.jp","niigata.niigata.jp","ojiya.niigata.jp","omi.niigata.jp","sado.niigata.jp","sanjo.niigata.jp","seiro.niigata.jp","seirou.niigata.jp","sekikawa.niigata.jp","shibata.niigata.jp","tagami.niigata.jp","tainai.niigata.jp","tochio.niigata.jp","tokamachi.niigata.jp","tsubame.niigata.jp","tsunan.niigata.jp","uonuma.niigata.jp","yahiko.niigata.jp","yoita.niigata.jp","yuzawa.niigata.jp","beppu.oita.jp","bungoono.oita.jp","bungotakada.oita.jp","hasama.oita.jp","hiji.oita.jp","himeshima.oita.jp","hita.oita.jp","kamitsue.oita.jp","kokonoe.oita.jp","kuju.oita.jp","kunisaki.oita.jp","kusu.oita.jp","oita.oita.jp","saiki.oita.jp","taketa.oita.jp","tsukumi.oita.jp","usa.oita.jp","usuki.oita.jp","yufu.oita.jp","akaiwa.okayama.jp","asakuchi.okayama.jp","bizen.okayama.jp","hayashima.okayama.jp","ibara.okayama.jp","kagamino.okayama.jp","kasaoka.okayama.jp","kibichuo.okayama.jp","kumenan.okayama.jp","kurashiki.okayama.jp","maniwa.okayama.jp","misaki.okayama.jp","nagi.okayama.jp","niimi.okayama.jp","nishiawakura.okayama.jp","okayama.okayama.jp","satosho.okayama.jp","setouchi.okayama.jp","shinjo.okayama.jp","shoo.okayama.jp","soja.okayama.jp","takahashi.okayama.jp","tamano.okayama.jp","tsuyama.okayama.jp","wake.okayama.jp","yakage.okayama.jp","aguni.okinawa.jp","ginowan.okinawa.jp","ginoza.okinawa.jp","gushikami.okinawa.jp","haebaru.okinawa.jp","higashi.okinawa.jp","hirara.okinawa.jp","iheya.okinawa.jp","ishigaki.okinawa.jp","ishikawa.okinawa.jp","itoman.okinawa.jp","izena.okinawa.jp","kadena.okinawa.jp","kin.okinawa.jp","kitadaito.okinawa.jp","kitanakagusuku.okinawa.jp","kumejima.okinawa.jp","kunigami.okinawa.jp","minamidaito.okinawa.jp","motobu.okinawa.jp","nago.okinawa.jp","naha.okinawa.jp","nakagusuku.okinawa.jp","nakijin.okinawa.jp","nanjo.okinawa.jp","nishihara.okinawa.jp","ogimi.okinawa.jp","okinawa.okinawa.jp","onna.okinawa.jp","shimoji.okinawa.jp","taketomi.okinawa.jp","tarama.okinawa.jp","tokashiki.okinawa.jp","tomigusuku.okinawa.jp","tonaki.okinawa.jp","urasoe.okinawa.jp","uruma.okinawa.jp","yaese.okinawa.jp","yomitan.okinawa.jp","yonabaru.okinawa.jp","yonaguni.okinawa.jp","zamami.okinawa.jp","abeno.osaka.jp","chihayaakasaka.osaka.jp","chuo.osaka.jp","daito.osaka.jp","fujiidera.osaka.jp","habikino.osaka.jp","hannan.osaka.jp","higashiosaka.osaka.jp","higashisumiyoshi.osaka.jp","higashiyodogawa.osaka.jp","hirakata.osaka.jp","ibaraki.osaka.jp","ikeda.osaka.jp","izumi.osaka.jp","izumiotsu.osaka.jp","izumisano.osaka.jp","kadoma.osaka.jp","kaizuka.osaka.jp","kanan.osaka.jp","kashiwara.osaka.jp","katano.osaka.jp","kawachinagano.osaka.jp","kishiwada.osaka.jp","kita.osaka.jp","kumatori.osaka.jp","matsubara.osaka.jp","minato.osaka.jp","minoh.osaka.jp","misaki.osaka.jp","moriguchi.osaka.jp","neyagawa.osaka.jp","nishi.osaka.jp","nose.osaka.jp","osakasayama.osaka.jp","sakai.osaka.jp","sayama.osaka.jp","sennan.osaka.jp","settsu.osaka.jp","shijonawate.osaka.jp","shimamoto.osaka.jp","suita.osaka.jp","tadaoka.osaka.jp","taishi.osaka.jp","tajiri.osaka.jp","takaishi.osaka.jp","takatsuki.osaka.jp","tondabayashi.osaka.jp","toyonaka.osaka.jp","toyono.osaka.jp","yao.osaka.jp","ariake.saga.jp","arita.saga.jp","fukudomi.saga.jp","genkai.saga.jp","hamatama.saga.jp","hizen.saga.jp","imari.saga.jp","kamimine.saga.jp","kanzaki.saga.jp","karatsu.saga.jp","kashima.saga.jp","kitagata.saga.jp","kitahata.saga.jp","kiyama.saga.jp","kouhoku.saga.jp","kyuragi.saga.jp","nishiarita.saga.jp","ogi.saga.jp","omachi.saga.jp","ouchi.saga.jp","saga.saga.jp","shiroishi.saga.jp","taku.saga.jp","tara.saga.jp","tosu.saga.jp","yoshinogari.saga.jp","arakawa.saitama.jp","asaka.saitama.jp","chichibu.saitama.jp","fujimi.saitama.jp","fujimino.saitama.jp","fukaya.saitama.jp","hanno.saitama.jp","hanyu.saitama.jp","hasuda.saitama.jp","hatogaya.saitama.jp","hatoyama.saitama.jp","hidaka.saitama.jp","higashichichibu.saitama.jp","higashimatsuyama.saitama.jp","honjo.saitama.jp","ina.saitama.jp","iruma.saitama.jp","iwatsuki.saitama.jp","kamiizumi.saitama.jp","kamikawa.saitama.jp","kamisato.saitama.jp","kasukabe.saitama.jp","kawagoe.saitama.jp","kawaguchi.saitama.jp","kawajima.saitama.jp","kazo.saitama.jp","kitamoto.saitama.jp","koshigaya.saitama.jp","kounosu.saitama.jp","kuki.saitama.jp","kumagaya.saitama.jp","matsubushi.saitama.jp","minano.saitama.jp","misato.saitama.jp","miyashiro.saitama.jp","miyoshi.saitama.jp","moroyama.saitama.jp","nagatoro.saitama.jp","namegawa.saitama.jp","niiza.saitama.jp","ogano.saitama.jp","ogawa.saitama.jp","ogose.saitama.jp","okegawa.saitama.jp","omiya.saitama.jp","otaki.saitama.jp","ranzan.saitama.jp","ryokami.saitama.jp","saitama.saitama.jp","sakado.saitama.jp","satte.saitama.jp","sayama.saitama.jp","shiki.saitama.jp","shiraoka.saitama.jp","soka.saitama.jp","sugito.saitama.jp","toda.saitama.jp","tokigawa.saitama.jp","tokorozawa.saitama.jp","tsurugashima.saitama.jp","urawa.saitama.jp","warabi.saitama.jp","yashio.saitama.jp","yokoze.saitama.jp","yono.saitama.jp","yorii.saitama.jp","yoshida.saitama.jp","yoshikawa.saitama.jp","yoshimi.saitama.jp","aisho.shiga.jp","gamo.shiga.jp","higashiomi.shiga.jp","hikone.shiga.jp","koka.shiga.jp","konan.shiga.jp","kosei.shiga.jp","koto.shiga.jp","kusatsu.shiga.jp","maibara.shiga.jp","moriyama.shiga.jp","nagahama.shiga.jp","nishiazai.shiga.jp","notogawa.shiga.jp","omihachiman.shiga.jp","otsu.shiga.jp","ritto.shiga.jp","ryuoh.shiga.jp","takashima.shiga.jp","takatsuki.shiga.jp","torahime.shiga.jp","toyosato.shiga.jp","yasu.shiga.jp","akagi.shimane.jp","ama.shimane.jp","gotsu.shimane.jp","hamada.shimane.jp","higashiizumo.shimane.jp","hikawa.shimane.jp","hikimi.shimane.jp","izumo.shimane.jp","kakinoki.shimane.jp","masuda.shimane.jp","matsue.shimane.jp","misato.shimane.jp","nishinoshima.shimane.jp","ohda.shimane.jp","okinoshima.shimane.jp","okuizumo.shimane.jp","shimane.shimane.jp","tamayu.shimane.jp","tsuwano.shimane.jp","unnan.shimane.jp","yakumo.shimane.jp","yasugi.shimane.jp","yatsuka.shimane.jp","arai.shizuoka.jp","atami.shizuoka.jp","fuji.shizuoka.jp","fujieda.shizuoka.jp","fujikawa.shizuoka.jp","fujinomiya.shizuoka.jp","fukuroi.shizuoka.jp","gotemba.shizuoka.jp","haibara.shizuoka.jp","hamamatsu.shizuoka.jp","higashiizu.shizuoka.jp","ito.shizuoka.jp","iwata.shizuoka.jp","izu.shizuoka.jp","izunokuni.shizuoka.jp","kakegawa.shizuoka.jp","kannami.shizuoka.jp","kawanehon.shizuoka.jp","kawazu.shizuoka.jp","kikugawa.shizuoka.jp","kosai.shizuoka.jp","makinohara.shizuoka.jp","matsuzaki.shizuoka.jp","minamiizu.shizuoka.jp","mishima.shizuoka.jp","morimachi.shizuoka.jp","nishiizu.shizuoka.jp","numazu.shizuoka.jp","omaezaki.shizuoka.jp","shimada.shizuoka.jp","shimizu.shizuoka.jp","shimoda.shizuoka.jp","shizuoka.shizuoka.jp","susono.shizuoka.jp","yaizu.shizuoka.jp","yoshida.shizuoka.jp","ashikaga.tochigi.jp","bato.tochigi.jp","haga.tochigi.jp","ichikai.tochigi.jp","iwafune.tochigi.jp","kaminokawa.tochigi.jp","kanuma.tochigi.jp","karasuyama.tochigi.jp","kuroiso.tochigi.jp","mashiko.tochigi.jp","mibu.tochigi.jp","moka.tochigi.jp","motegi.tochigi.jp","nasu.tochigi.jp","nasushiobara.tochigi.jp","nikko.tochigi.jp","nishikata.tochigi.jp","nogi.tochigi.jp","ohira.tochigi.jp","ohtawara.tochigi.jp","oyama.tochigi.jp","sakura.tochigi.jp","sano.tochigi.jp","shimotsuke.tochigi.jp","shioya.tochigi.jp","takanezawa.tochigi.jp","tochigi.tochigi.jp","tsuga.tochigi.jp","ujiie.tochigi.jp","utsunomiya.tochigi.jp","yaita.tochigi.jp","aizumi.tokushima.jp","anan.tokushima.jp","ichiba.tokushima.jp","itano.tokushima.jp","kainan.tokushima.jp","komatsushima.tokushima.jp","matsushige.tokushima.jp","mima.tokushima.jp","minami.tokushima.jp","miyoshi.tokushima.jp","mugi.tokushima.jp","nakagawa.tokushima.jp","naruto.tokushima.jp","sanagochi.tokushima.jp","shishikui.tokushima.jp","tokushima.tokushima.jp","wajiki.tokushima.jp","adachi.tokyo.jp","akiruno.tokyo.jp","akishima.tokyo.jp","aogashima.tokyo.jp","arakawa.tokyo.jp","bunkyo.tokyo.jp","chiyoda.tokyo.jp","chofu.tokyo.jp","chuo.tokyo.jp","edogawa.tokyo.jp","fuchu.tokyo.jp","fussa.tokyo.jp","hachijo.tokyo.jp","hachioji.tokyo.jp","hamura.tokyo.jp","higashikurume.tokyo.jp","higashimurayama.tokyo.jp","higashiyamato.tokyo.jp","hino.tokyo.jp","hinode.tokyo.jp","hinohara.tokyo.jp","inagi.tokyo.jp","itabashi.tokyo.jp","katsushika.tokyo.jp","kita.tokyo.jp","kiyose.tokyo.jp","kodaira.tokyo.jp","koganei.tokyo.jp","kokubunji.tokyo.jp","komae.tokyo.jp","koto.tokyo.jp","kouzushima.tokyo.jp","kunitachi.tokyo.jp","machida.tokyo.jp","meguro.tokyo.jp","minato.tokyo.jp","mitaka.tokyo.jp","mizuho.tokyo.jp","musashimurayama.tokyo.jp","musashino.tokyo.jp","nakano.tokyo.jp","nerima.tokyo.jp","ogasawara.tokyo.jp","okutama.tokyo.jp","ome.tokyo.jp","oshima.tokyo.jp","ota.tokyo.jp","setagaya.tokyo.jp","shibuya.tokyo.jp","shinagawa.tokyo.jp","shinjuku.tokyo.jp","suginami.tokyo.jp","sumida.tokyo.jp","tachikawa.tokyo.jp","taito.tokyo.jp","tama.tokyo.jp","toshima.tokyo.jp","chizu.tottori.jp","hino.tottori.jp","kawahara.tottori.jp","koge.tottori.jp","kotoura.tottori.jp","misasa.tottori.jp","nanbu.tottori.jp","nichinan.tottori.jp","sakaiminato.tottori.jp","tottori.tottori.jp","wakasa.tottori.jp","yazu.tottori.jp","yonago.tottori.jp","asahi.toyama.jp","fuchu.toyama.jp","fukumitsu.toyama.jp","funahashi.toyama.jp","himi.toyama.jp","imizu.toyama.jp","inami.toyama.jp","johana.toyama.jp","kamiichi.toyama.jp","kurobe.toyama.jp","nakaniikawa.toyama.jp","namerikawa.toyama.jp","nanto.toyama.jp","nyuzen.toyama.jp","oyabe.toyama.jp","taira.toyama.jp","takaoka.toyama.jp","tateyama.toyama.jp","toga.toyama.jp","tonami.toyama.jp","toyama.toyama.jp","unazuki.toyama.jp","uozu.toyama.jp","yamada.toyama.jp","arida.wakayama.jp","aridagawa.wakayama.jp","gobo.wakayama.jp","hashimoto.wakayama.jp","hidaka.wakayama.jp","hirogawa.wakayama.jp","inami.wakayama.jp","iwade.wakayama.jp","kainan.wakayama.jp","kamitonda.wakayama.jp","katsuragi.wakayama.jp","kimino.wakayama.jp","kinokawa.wakayama.jp","kitayama.wakayama.jp","koya.wakayama.jp","koza.wakayama.jp","kozagawa.wakayama.jp","kudoyama.wakayama.jp","kushimoto.wakayama.jp","mihama.wakayama.jp","misato.wakayama.jp","nachikatsuura.wakayama.jp","shingu.wakayama.jp","shirahama.wakayama.jp","taiji.wakayama.jp","tanabe.wakayama.jp","wakayama.wakayama.jp","yuasa.wakayama.jp","yura.wakayama.jp","asahi.yamagata.jp","funagata.yamagata.jp","higashine.yamagata.jp","iide.yamagata.jp","kahoku.yamagata.jp","kaminoyama.yamagata.jp","kaneyama.yamagata.jp","kawanishi.yamagata.jp","mamurogawa.yamagata.jp","mikawa.yamagata.jp","murayama.yamagata.jp","nagai.yamagata.jp","nakayama.yamagata.jp","nanyo.yamagata.jp","nishikawa.yamagata.jp","obanazawa.yamagata.jp","oe.yamagata.jp","oguni.yamagata.jp","ohkura.yamagata.jp","oishida.yamagata.jp","sagae.yamagata.jp","sakata.yamagata.jp","sakegawa.yamagata.jp","shinjo.yamagata.jp","shirataka.yamagata.jp","shonai.yamagata.jp","takahata.yamagata.jp","tendo.yamagata.jp","tozawa.yamagata.jp","tsuruoka.yamagata.jp","yamagata.yamagata.jp","yamanobe.yamagata.jp","yonezawa.yamagata.jp","yuza.yamagata.jp","abu.yamaguchi.jp","hagi.yamaguchi.jp","hikari.yamaguchi.jp","hofu.yamaguchi.jp","iwakuni.yamaguchi.jp","kudamatsu.yamaguchi.jp","mitou.yamaguchi.jp","nagato.yamaguchi.jp","oshima.yamaguchi.jp","shimonoseki.yamaguchi.jp","shunan.yamaguchi.jp","tabuse.yamaguchi.jp","tokuyama.yamaguchi.jp","toyota.yamaguchi.jp","ube.yamaguchi.jp","yuu.yamaguchi.jp","chuo.yamanashi.jp","doshi.yamanashi.jp","fuefuki.yamanashi.jp","fujikawa.yamanashi.jp","fujikawaguchiko.yamanashi.jp","fujiyoshida.yamanashi.jp","hayakawa.yamanashi.jp","hokuto.yamanashi.jp","ichikawamisato.yamanashi.jp","kai.yamanashi.jp","kofu.yamanashi.jp","koshu.yamanashi.jp","kosuge.yamanashi.jp","minami-alps.yamanashi.jp","minobu.yamanashi.jp","nakamichi.yamanashi.jp","nanbu.yamanashi.jp","narusawa.yamanashi.jp","nirasaki.yamanashi.jp","nishikatsura.yamanashi.jp","oshino.yamanashi.jp","otsuki.yamanashi.jp","showa.yamanashi.jp","tabayama.yamanashi.jp","tsuru.yamanashi.jp","uenohara.yamanashi.jp","yamanakako.yamanashi.jp","yamanashi.yamanashi.jp","ke","ac.ke","co.ke","go.ke","info.ke","me.ke","mobi.ke","ne.ke","or.ke","sc.ke","kg","org.kg","net.kg","com.kg","edu.kg","gov.kg","mil.kg","*.kh","ki","edu.ki","biz.ki","net.ki","org.ki","gov.ki","info.ki","com.ki","km","org.km","nom.km","gov.km","prd.km","tm.km","edu.km","mil.km","ass.km","com.km","coop.km","asso.km","presse.km","medecin.km","notaires.km","pharmaciens.km","veterinaire.km","gouv.km","kn","net.kn","org.kn","edu.kn","gov.kn","kp","com.kp","edu.kp","gov.kp","org.kp","rep.kp","tra.kp","kr","ac.kr","co.kr","es.kr","go.kr","hs.kr","kg.kr","mil.kr","ms.kr","ne.kr","or.kr","pe.kr","re.kr","sc.kr","busan.kr","chungbuk.kr","chungnam.kr","daegu.kr","daejeon.kr","gangwon.kr","gwangju.kr","gyeongbuk.kr","gyeonggi.kr","gyeongnam.kr","incheon.kr","jeju.kr","jeonbuk.kr","jeonnam.kr","seoul.kr","ulsan.kr","kw","com.kw","edu.kw","emb.kw","gov.kw","ind.kw","net.kw","org.kw","ky","edu.ky","gov.ky","com.ky","org.ky","net.ky","kz","org.kz","edu.kz","net.kz","gov.kz","mil.kz","com.kz","la","int.la","net.la","info.la","edu.la","gov.la","per.la","com.la","org.la","lb","com.lb","edu.lb","gov.lb","net.lb","org.lb","lc","com.lc","net.lc","co.lc","org.lc","edu.lc","gov.lc","li","lk","gov.lk","sch.lk","net.lk","int.lk","com.lk","org.lk","edu.lk","ngo.lk","soc.lk","web.lk","ltd.lk","assn.lk","grp.lk","hotel.lk","ac.lk","lr","com.lr","edu.lr","gov.lr","org.lr","net.lr","ls","ac.ls","biz.ls","co.ls","edu.ls","gov.ls","info.ls","net.ls","org.ls","sc.ls","lt","gov.lt","lu","lv","com.lv","edu.lv","gov.lv","org.lv","mil.lv","id.lv","net.lv","asn.lv","conf.lv","ly","com.ly","net.ly","gov.ly","plc.ly","edu.ly","sch.ly","med.ly","org.ly","id.ly","ma","co.ma","net.ma","gov.ma","org.ma","ac.ma","press.ma","mc","tm.mc","asso.mc","md","me","co.me","net.me","org.me","edu.me","ac.me","gov.me","its.me","priv.me","mg","org.mg","nom.mg","gov.mg","prd.mg","tm.mg","edu.mg","mil.mg","com.mg","co.mg","mh","mil","mk","com.mk","org.mk","net.mk","edu.mk","gov.mk","inf.mk","name.mk","ml","com.ml","edu.ml","gouv.ml","gov.ml","net.ml","org.ml","presse.ml","*.mm","mn","gov.mn","edu.mn","org.mn","mo","com.mo","net.mo","org.mo","edu.mo","gov.mo","mobi","mp","mq","mr","gov.mr","ms","com.ms","edu.ms","gov.ms","net.ms","org.ms","mt","com.mt","edu.mt","net.mt","org.mt","mu","com.mu","net.mu","org.mu","gov.mu","ac.mu","co.mu","or.mu","museum","academy.museum","agriculture.museum","air.museum","airguard.museum","alabama.museum","alaska.museum","amber.museum","ambulance.museum","american.museum","americana.museum","americanantiques.museum","americanart.museum","amsterdam.museum","and.museum","annefrank.museum","anthro.museum","anthropology.museum","antiques.museum","aquarium.museum","arboretum.museum","archaeological.museum","archaeology.museum","architecture.museum","art.museum","artanddesign.museum","artcenter.museum","artdeco.museum","arteducation.museum","artgallery.museum","arts.museum","artsandcrafts.museum","asmatart.museum","assassination.museum","assisi.museum","association.museum","astronomy.museum","atlanta.museum","austin.museum","australia.museum","automotive.museum","aviation.museum","axis.museum","badajoz.museum","baghdad.museum","bahn.museum","bale.museum","baltimore.museum","barcelona.museum","baseball.museum","basel.museum","baths.museum","bauern.museum","beauxarts.museum","beeldengeluid.museum","bellevue.museum","bergbau.museum","berkeley.museum","berlin.museum","bern.museum","bible.museum","bilbao.museum","bill.museum","birdart.museum","birthplace.museum","bonn.museum","boston.museum","botanical.museum","botanicalgarden.museum","botanicgarden.museum","botany.museum","brandywinevalley.museum","brasil.museum","bristol.museum","british.museum","britishcolumbia.museum","broadcast.museum","brunel.museum","brussel.museum","brussels.museum","bruxelles.museum","building.museum","burghof.museum","bus.museum","bushey.museum","cadaques.museum","california.museum","cambridge.museum","can.museum","canada.museum","capebreton.museum","carrier.museum","cartoonart.museum","casadelamoneda.museum","castle.museum","castres.museum","celtic.museum","center.museum","chattanooga.museum","cheltenham.museum","chesapeakebay.museum","chicago.museum","children.museum","childrens.museum","childrensgarden.museum","chiropractic.museum","chocolate.museum","christiansburg.museum","cincinnati.museum","cinema.museum","circus.museum","civilisation.museum","civilization.museum","civilwar.museum","clinton.museum","clock.museum","coal.museum","coastaldefence.museum","cody.museum","coldwar.museum","collection.museum","colonialwilliamsburg.museum","coloradoplateau.museum","columbia.museum","columbus.museum","communication.museum","communications.museum","community.museum","computer.museum","computerhistory.museum","comunicações.museum","contemporary.museum","contemporaryart.museum","convent.museum","copenhagen.museum","corporation.museum","correios-e-telecomunicações.museum","corvette.museum","costume.museum","countryestate.museum","county.museum","crafts.museum","cranbrook.museum","creation.museum","cultural.museum","culturalcenter.museum","culture.museum","cyber.museum","cymru.museum","dali.museum","dallas.museum","database.museum","ddr.museum","decorativearts.museum","delaware.museum","delmenhorst.museum","denmark.museum","depot.museum","design.museum","detroit.museum","dinosaur.museum","discovery.museum","dolls.museum","donostia.museum","durham.museum","eastafrica.museum","eastcoast.museum","education.museum","educational.museum","egyptian.museum","eisenbahn.museum","elburg.museum","elvendrell.museum","embroidery.museum","encyclopedic.museum","england.museum","entomology.museum","environment.museum","environmentalconservation.museum","epilepsy.museum","essex.museum","estate.museum","ethnology.museum","exeter.museum","exhibition.museum","family.museum","farm.museum","farmequipment.museum","farmers.museum","farmstead.museum","field.museum","figueres.museum","filatelia.museum","film.museum","fineart.museum","finearts.museum","finland.museum","flanders.museum","florida.museum","force.museum","fortmissoula.museum","fortworth.museum","foundation.museum","francaise.museum","frankfurt.museum","franziskaner.museum","freemasonry.museum","freiburg.museum","fribourg.museum","frog.museum","fundacio.museum","furniture.museum","gallery.museum","garden.museum","gateway.museum","geelvinck.museum","gemological.museum","geology.museum","georgia.museum","giessen.museum","glas.museum","glass.museum","gorge.museum","grandrapids.museum","graz.museum","guernsey.museum","halloffame.museum","hamburg.museum","handson.museum","harvestcelebration.museum","hawaii.museum","health.museum","heimatunduhren.museum","hellas.museum","helsinki.museum","hembygdsforbund.museum","heritage.museum","histoire.museum","historical.museum","historicalsociety.museum","historichouses.museum","historisch.museum","historisches.museum","history.museum","historyofscience.museum","horology.museum","house.museum","humanities.museum","illustration.museum","imageandsound.museum","indian.museum","indiana.museum","indianapolis.museum","indianmarket.museum","intelligence.museum","interactive.museum","iraq.museum","iron.museum","isleofman.museum","jamison.museum","jefferson.museum","jerusalem.museum","jewelry.museum","jewish.museum","jewishart.museum","jfk.museum","journalism.museum","judaica.museum","judygarland.museum","juedisches.museum","juif.museum","karate.museum","karikatur.museum","kids.museum","koebenhavn.museum","koeln.museum","kunst.museum","kunstsammlung.museum","kunstunddesign.museum","labor.museum","labour.museum","lajolla.museum","lancashire.museum","landes.museum","lans.museum","läns.museum","larsson.museum","lewismiller.museum","lincoln.museum","linz.museum","living.museum","livinghistory.museum","localhistory.museum","london.museum","losangeles.museum","louvre.museum","loyalist.museum","lucerne.museum","luxembourg.museum","luzern.museum","mad.museum","madrid.museum","mallorca.museum","manchester.museum","mansion.museum","mansions.museum","manx.museum","marburg.museum","maritime.museum","maritimo.museum","maryland.museum","marylhurst.museum","media.museum","medical.museum","medizinhistorisches.museum","meeres.museum","memorial.museum","mesaverde.museum","michigan.museum","midatlantic.museum","military.museum","mill.museum","miners.museum","mining.museum","minnesota.museum","missile.museum","missoula.museum","modern.museum","moma.museum","money.museum","monmouth.museum","monticello.museum","montreal.museum","moscow.museum","motorcycle.museum","muenchen.museum","muenster.museum","mulhouse.museum","muncie.museum","museet.museum","museumcenter.museum","museumvereniging.museum","music.museum","national.museum","nationalfirearms.museum","nationalheritage.museum","nativeamerican.museum","naturalhistory.museum","naturalhistorymuseum.museum","naturalsciences.museum","nature.museum","naturhistorisches.museum","natuurwetenschappen.museum","naumburg.museum","naval.museum","nebraska.museum","neues.museum","newhampshire.museum","newjersey.museum","newmexico.museum","newport.museum","newspaper.museum","newyork.museum","niepce.museum","norfolk.museum","north.museum","nrw.museum","nyc.museum","nyny.museum","oceanographic.museum","oceanographique.museum","omaha.museum","online.museum","ontario.museum","openair.museum","oregon.museum","oregontrail.museum","otago.museum","oxford.museum","pacific.museum","paderborn.museum","palace.museum","paleo.museum","palmsprings.museum","panama.museum","paris.museum","pasadena.museum","pharmacy.museum","philadelphia.museum","philadelphiaarea.museum","philately.museum","phoenix.museum","photography.museum","pilots.museum","pittsburgh.museum","planetarium.museum","plantation.museum","plants.museum","plaza.museum","portal.museum","portland.museum","portlligat.museum","posts-and-telecommunications.museum","preservation.museum","presidio.museum","press.museum","project.museum","public.museum","pubol.museum","quebec.museum","railroad.museum","railway.museum","research.museum","resistance.museum","riodejaneiro.museum","rochester.museum","rockart.museum","roma.museum","russia.museum","saintlouis.museum","salem.museum","salvadordali.museum","salzburg.museum","sandiego.museum","sanfrancisco.museum","santabarbara.museum","santacruz.museum","santafe.museum","saskatchewan.museum","satx.museum","savannahga.museum","schlesisches.museum","schoenbrunn.museum","schokoladen.museum","school.museum","schweiz.museum","science.museum","scienceandhistory.museum","scienceandindustry.museum","sciencecenter.museum","sciencecenters.museum","science-fiction.museum","sciencehistory.museum","sciences.museum","sciencesnaturelles.museum","scotland.museum","seaport.museum","settlement.museum","settlers.museum","shell.museum","sherbrooke.museum","sibenik.museum","silk.museum","ski.museum","skole.museum","society.museum","sologne.museum","soundandvision.museum","southcarolina.museum","southwest.museum","space.museum","spy.museum","square.museum","stadt.museum","stalbans.museum","starnberg.museum","state.museum","stateofdelaware.museum","station.museum","steam.museum","steiermark.museum","stjohn.museum","stockholm.museum","stpetersburg.museum","stuttgart.museum","suisse.museum","surgeonshall.museum","surrey.museum","svizzera.museum","sweden.museum","sydney.museum","tank.museum","tcm.museum","technology.museum","telekommunikation.museum","television.museum","texas.museum","textile.museum","theater.museum","time.museum","timekeeping.museum","topology.museum","torino.museum","touch.museum","town.museum","transport.museum","tree.museum","trolley.museum","trust.museum","trustee.museum","uhren.museum","ulm.museum","undersea.museum","university.museum","usa.museum","usantiques.museum","usarts.museum","uscountryestate.museum","usculture.museum","usdecorativearts.museum","usgarden.museum","ushistory.museum","ushuaia.museum","uslivinghistory.museum","utah.museum","uvic.museum","valley.museum","vantaa.museum","versailles.museum","viking.museum","village.museum","virginia.museum","virtual.museum","virtuel.museum","vlaanderen.museum","volkenkunde.museum","wales.museum","wallonie.museum","war.museum","washingtondc.museum","watchandclock.museum","watch-and-clock.museum","western.museum","westfalen.museum","whaling.museum","wildlife.museum","williamsburg.museum","windmill.museum","workshop.museum","york.museum","yorkshire.museum","yosemite.museum","youth.museum","zoological.museum","zoology.museum","ירושלים.museum","иком.museum","mv","aero.mv","biz.mv","com.mv","coop.mv","edu.mv","gov.mv","info.mv","int.mv","mil.mv","museum.mv","name.mv","net.mv","org.mv","pro.mv","mw","ac.mw","biz.mw","co.mw","com.mw","coop.mw","edu.mw","gov.mw","int.mw","museum.mw","net.mw","org.mw","mx","com.mx","org.mx","gob.mx","edu.mx","net.mx","my","com.my","net.my","org.my","gov.my","edu.my","mil.my","name.my","mz","ac.mz","adv.mz","co.mz","edu.mz","gov.mz","mil.mz","net.mz","org.mz","na","info.na","pro.na","name.na","school.na","or.na","dr.na","us.na","mx.na","ca.na","in.na","cc.na","tv.na","ws.na","mobi.na","co.na","com.na","org.na","name","nc","asso.nc","nom.nc","ne","net","nf","com.nf","net.nf","per.nf","rec.nf","web.nf","arts.nf","firm.nf","info.nf","other.nf","store.nf","ng","com.ng","edu.ng","gov.ng","i.ng","mil.ng","mobi.ng","name.ng","net.ng","org.ng","sch.ng","ni","ac.ni","biz.ni","co.ni","com.ni","edu.ni","gob.ni","in.ni","info.ni","int.ni","mil.ni","net.ni","nom.ni","org.ni","web.ni","nl","no","fhs.no","vgs.no","fylkesbibl.no","folkebibl.no","museum.no","idrett.no","priv.no","mil.no","stat.no","dep.no","kommune.no","herad.no","aa.no","ah.no","bu.no","fm.no","hl.no","hm.no","jan-mayen.no","mr.no","nl.no","nt.no","of.no","ol.no","oslo.no","rl.no","sf.no","st.no","svalbard.no","tm.no","tr.no","va.no","vf.no","gs.aa.no","gs.ah.no","gs.bu.no","gs.fm.no","gs.hl.no","gs.hm.no","gs.jan-mayen.no","gs.mr.no","gs.nl.no","gs.nt.no","gs.of.no","gs.ol.no","gs.oslo.no","gs.rl.no","gs.sf.no","gs.st.no","gs.svalbard.no","gs.tm.no","gs.tr.no","gs.va.no","gs.vf.no","akrehamn.no","åkrehamn.no","algard.no","ålgård.no","arna.no","brumunddal.no","bryne.no","bronnoysund.no","brønnøysund.no","drobak.no","drøbak.no","egersund.no","fetsund.no","floro.no","florø.no","fredrikstad.no","hokksund.no","honefoss.no","hønefoss.no","jessheim.no","jorpeland.no","jørpeland.no","kirkenes.no","kopervik.no","krokstadelva.no","langevag.no","langevåg.no","leirvik.no","mjondalen.no","mjøndalen.no","mo-i-rana.no","mosjoen.no","mosjøen.no","nesoddtangen.no","orkanger.no","osoyro.no","osøyro.no","raholt.no","råholt.no","sandnessjoen.no","sandnessjøen.no","skedsmokorset.no","slattum.no","spjelkavik.no","stathelle.no","stavern.no","stjordalshalsen.no","stjørdalshalsen.no","tananger.no","tranby.no","vossevangen.no","afjord.no","åfjord.no","agdenes.no","al.no","ål.no","alesund.no","ålesund.no","alstahaug.no","alta.no","áltá.no","alaheadju.no","álaheadju.no","alvdal.no","amli.no","åmli.no","amot.no","åmot.no","andebu.no","andoy.no","andøy.no","andasuolo.no","ardal.no","årdal.no","aremark.no","arendal.no","ås.no","aseral.no","åseral.no","asker.no","askim.no","askvoll.no","askoy.no","askøy.no","asnes.no","åsnes.no","audnedaln.no","aukra.no","aure.no","aurland.no","aurskog-holand.no","aurskog-høland.no","austevoll.no","austrheim.no","averoy.no","averøy.no","balestrand.no","ballangen.no","balat.no","bálát.no","balsfjord.no","bahccavuotna.no","báhccavuotna.no","bamble.no","bardu.no","beardu.no","beiarn.no","bajddar.no","bájddar.no","baidar.no","báidár.no","berg.no","bergen.no","berlevag.no","berlevåg.no","bearalvahki.no","bearalváhki.no","bindal.no","birkenes.no","bjarkoy.no","bjarkøy.no","bjerkreim.no","bjugn.no","bodo.no","bodø.no","badaddja.no","bådåddjå.no","budejju.no","bokn.no","bremanger.no","bronnoy.no","brønnøy.no","bygland.no","bykle.no","barum.no","bærum.no","bo.telemark.no","bø.telemark.no","bo.nordland.no","bø.nordland.no","bievat.no","bievát.no","bomlo.no","bømlo.no","batsfjord.no","båtsfjord.no","bahcavuotna.no","báhcavuotna.no","dovre.no","drammen.no","drangedal.no","dyroy.no","dyrøy.no","donna.no","dønna.no","eid.no","eidfjord.no","eidsberg.no","eidskog.no","eidsvoll.no","eigersund.no","elverum.no","enebakk.no","engerdal.no","etne.no","etnedal.no","evenes.no","evenassi.no","evenášši.no","evje-og-hornnes.no","farsund.no","fauske.no","fuossko.no","fuoisku.no","fedje.no","fet.no","finnoy.no","finnøy.no","fitjar.no","fjaler.no","fjell.no","flakstad.no","flatanger.no","flekkefjord.no","flesberg.no","flora.no","fla.no","flå.no","folldal.no","forsand.no","fosnes.no","frei.no","frogn.no","froland.no","frosta.no","frana.no","fræna.no","froya.no","frøya.no","fusa.no","fyresdal.no","forde.no","førde.no","gamvik.no","gangaviika.no","gáŋgaviika.no","gaular.no","gausdal.no","gildeskal.no","gildeskål.no","giske.no","gjemnes.no","gjerdrum.no","gjerstad.no","gjesdal.no","gjovik.no","gjøvik.no","gloppen.no","gol.no","gran.no","grane.no","granvin.no","gratangen.no","grimstad.no","grong.no","kraanghke.no","kråanghke.no","grue.no","gulen.no","hadsel.no","halden.no","halsa.no","hamar.no","hamaroy.no","habmer.no","hábmer.no","hapmir.no","hápmir.no","hammerfest.no","hammarfeasta.no","hámmárfeasta.no","haram.no","hareid.no","harstad.no","hasvik.no","aknoluokta.no","ákŋoluokta.no","hattfjelldal.no","aarborte.no","haugesund.no","hemne.no","hemnes.no","hemsedal.no","heroy.more-og-romsdal.no","herøy.møre-og-romsdal.no","heroy.nordland.no","herøy.nordland.no","hitra.no","hjartdal.no","hjelmeland.no","hobol.no","hobøl.no","hof.no","hol.no","hole.no","holmestrand.no","holtalen.no","holtålen.no","hornindal.no","horten.no","hurdal.no","hurum.no","hvaler.no","hyllestad.no","hagebostad.no","hægebostad.no","hoyanger.no","høyanger.no","hoylandet.no","høylandet.no","ha.no","hå.no","ibestad.no","inderoy.no","inderøy.no","iveland.no","jevnaker.no","jondal.no","jolster.no","jølster.no","karasjok.no","karasjohka.no","kárášjohka.no","karlsoy.no","galsa.no","gálsá.no","karmoy.no","karmøy.no","kautokeino.no","guovdageaidnu.no","klepp.no","klabu.no","klæbu.no","kongsberg.no","kongsvinger.no","kragero.no","kragerø.no","kristiansand.no","kristiansund.no","krodsherad.no","krødsherad.no","kvalsund.no","rahkkeravju.no","ráhkkerávju.no","kvam.no","kvinesdal.no","kvinnherad.no","kviteseid.no","kvitsoy.no","kvitsøy.no","kvafjord.no","kvæfjord.no","giehtavuoatna.no","kvanangen.no","kvænangen.no","navuotna.no","návuotna.no","kafjord.no","kåfjord.no","gaivuotna.no","gáivuotna.no","larvik.no","lavangen.no","lavagis.no","loabat.no","loabát.no","lebesby.no","davvesiida.no","leikanger.no","leirfjord.no","leka.no","leksvik.no","lenvik.no","leangaviika.no","leaŋgaviika.no","lesja.no","levanger.no","lier.no","lierne.no","lillehammer.no","lillesand.no","lindesnes.no","lindas.no","lindås.no","lom.no","loppa.no","lahppi.no","láhppi.no","lund.no","lunner.no","luroy.no","lurøy.no","luster.no","lyngdal.no","lyngen.no","ivgu.no","lardal.no","lerdal.no","lærdal.no","lodingen.no","lødingen.no","lorenskog.no","lørenskog.no","loten.no","løten.no","malvik.no","masoy.no","måsøy.no","muosat.no","muosát.no","mandal.no","marker.no","marnardal.no","masfjorden.no","meland.no","meldal.no","melhus.no","meloy.no","meløy.no","meraker.no","meråker.no","moareke.no","moåreke.no","midsund.no","midtre-gauldal.no","modalen.no","modum.no","molde.no","moskenes.no","moss.no","mosvik.no","malselv.no","målselv.no","malatvuopmi.no","málatvuopmi.no","namdalseid.no","aejrie.no","namsos.no","namsskogan.no","naamesjevuemie.no","nååmesjevuemie.no","laakesvuemie.no","nannestad.no","narvik.no","narviika.no","naustdal.no","nedre-eiker.no","nes.akershus.no","nes.buskerud.no","nesna.no","nesodden.no","nesseby.no","unjarga.no","unjárga.no","nesset.no","nissedal.no","nittedal.no","nord-aurdal.no","nord-fron.no","nord-odal.no","norddal.no","nordkapp.no","davvenjarga.no","davvenjárga.no","nordre-land.no","nordreisa.no","raisa.no","ráisa.no","nore-og-uvdal.no","notodden.no","naroy.no","nærøy.no","notteroy.no","nøtterøy.no","odda.no","oksnes.no","øksnes.no","oppdal.no","oppegard.no","oppegård.no","orkdal.no","orland.no","ørland.no","orskog.no","ørskog.no","orsta.no","ørsta.no","os.hedmark.no","os.hordaland.no","osen.no","osteroy.no","osterøy.no","ostre-toten.no","østre-toten.no","overhalla.no","ovre-eiker.no","øvre-eiker.no","oyer.no","øyer.no","oygarden.no","øygarden.no","oystre-slidre.no","øystre-slidre.no","porsanger.no","porsangu.no","porsáŋgu.no","porsgrunn.no","radoy.no","radøy.no","rakkestad.no","rana.no","ruovat.no","randaberg.no","rauma.no","rendalen.no","rennebu.no","rennesoy.no","rennesøy.no","rindal.no","ringebu.no","ringerike.no","ringsaker.no","rissa.no","risor.no","risør.no","roan.no","rollag.no","rygge.no","ralingen.no","rælingen.no","rodoy.no","rødøy.no","romskog.no","rømskog.no","roros.no","røros.no","rost.no","røst.no","royken.no","røyken.no","royrvik.no","røyrvik.no","rade.no","råde.no","salangen.no","siellak.no","saltdal.no","salat.no","sálát.no","sálat.no","samnanger.no","sande.more-og-romsdal.no","sande.møre-og-romsdal.no","sande.vestfold.no","sandefjord.no","sandnes.no","sandoy.no","sandøy.no","sarpsborg.no","sauda.no","sauherad.no","sel.no","selbu.no","selje.no","seljord.no","sigdal.no","siljan.no","sirdal.no","skaun.no","skedsmo.no","ski.no","skien.no","skiptvet.no","skjervoy.no","skjervøy.no","skierva.no","skiervá.no","skjak.no","skjåk.no","skodje.no","skanland.no","skånland.no","skanit.no","skánit.no","smola.no","smøla.no","snillfjord.no","snasa.no","snåsa.no","snoasa.no","snaase.no","snåase.no","sogndal.no","sokndal.no","sola.no","solund.no","songdalen.no","sortland.no","spydeberg.no","stange.no","stavanger.no","steigen.no","steinkjer.no","stjordal.no","stjørdal.no","stokke.no","stor-elvdal.no","stord.no","stordal.no","storfjord.no","omasvuotna.no","strand.no","stranda.no","stryn.no","sula.no","suldal.no","sund.no","sunndal.no","surnadal.no","sveio.no","svelvik.no","sykkylven.no","sogne.no","søgne.no","somna.no","sømna.no","sondre-land.no","søndre-land.no","sor-aurdal.no","sør-aurdal.no","sor-fron.no","sør-fron.no","sor-odal.no","sør-odal.no","sor-varanger.no","sør-varanger.no","matta-varjjat.no","mátta-várjjat.no","sorfold.no","sørfold.no","sorreisa.no","sørreisa.no","sorum.no","sørum.no","tana.no","deatnu.no","time.no","tingvoll.no","tinn.no","tjeldsund.no","dielddanuorri.no","tjome.no","tjøme.no","tokke.no","tolga.no","torsken.no","tranoy.no","tranøy.no","tromso.no","tromsø.no","tromsa.no","romsa.no","trondheim.no","troandin.no","trysil.no","trana.no","træna.no","trogstad.no","trøgstad.no","tvedestrand.no","tydal.no","tynset.no","tysfjord.no","divtasvuodna.no","divttasvuotna.no","tysnes.no","tysvar.no","tysvær.no","tonsberg.no","tønsberg.no","ullensaker.no","ullensvang.no","ulvik.no","utsira.no","vadso.no","vadsø.no","cahcesuolo.no","čáhcesuolo.no","vaksdal.no","valle.no","vang.no","vanylven.no","vardo.no","vardø.no","varggat.no","várggát.no","vefsn.no","vaapste.no","vega.no","vegarshei.no","vegårshei.no","vennesla.no","verdal.no","verran.no","vestby.no","vestnes.no","vestre-slidre.no","vestre-toten.no","vestvagoy.no","vestvågøy.no","vevelstad.no","vik.no","vikna.no","vindafjord.no","volda.no","voss.no","varoy.no","værøy.no","vagan.no","vågan.no","voagat.no","vagsoy.no","vågsøy.no","vaga.no","vågå.no","valer.ostfold.no","våler.østfold.no","valer.hedmark.no","våler.hedmark.no","*.np","nr","biz.nr","info.nr","gov.nr","edu.nr","org.nr","net.nr","com.nr","nu","nz","ac.nz","co.nz","cri.nz","geek.nz","gen.nz","govt.nz","health.nz","iwi.nz","kiwi.nz","maori.nz","mil.nz","māori.nz","net.nz","org.nz","parliament.nz","school.nz","om","co.om","com.om","edu.om","gov.om","med.om","museum.om","net.om","org.om","pro.om","onion","org","pa","ac.pa","gob.pa","com.pa","org.pa","sld.pa","edu.pa","net.pa","ing.pa","abo.pa","med.pa","nom.pa","pe","edu.pe","gob.pe","nom.pe","mil.pe","org.pe","com.pe","net.pe","pf","com.pf","org.pf","edu.pf","*.pg","ph","com.ph","net.ph","org.ph","gov.ph","edu.ph","ngo.ph","mil.ph","i.ph","pk","com.pk","net.pk","edu.pk","org.pk","fam.pk","biz.pk","web.pk","gov.pk","gob.pk","gok.pk","gon.pk","gop.pk","gos.pk","info.pk","pl","com.pl","net.pl","org.pl","aid.pl","agro.pl","atm.pl","auto.pl","biz.pl","edu.pl","gmina.pl","gsm.pl","info.pl","mail.pl","miasta.pl","media.pl","mil.pl","nieruchomosci.pl","nom.pl","pc.pl","powiat.pl","priv.pl","realestate.pl","rel.pl","sex.pl","shop.pl","sklep.pl","sos.pl","szkola.pl","targi.pl","tm.pl","tourism.pl","travel.pl","turystyka.pl","gov.pl","ap.gov.pl","ic.gov.pl","is.gov.pl","us.gov.pl","kmpsp.gov.pl","kppsp.gov.pl","kwpsp.gov.pl","psp.gov.pl","wskr.gov.pl","kwp.gov.pl","mw.gov.pl","ug.gov.pl","um.gov.pl","umig.gov.pl","ugim.gov.pl","upow.gov.pl","uw.gov.pl","starostwo.gov.pl","pa.gov.pl","po.gov.pl","psse.gov.pl","pup.gov.pl","rzgw.gov.pl","sa.gov.pl","so.gov.pl","sr.gov.pl","wsa.gov.pl","sko.gov.pl","uzs.gov.pl","wiih.gov.pl","winb.gov.pl","pinb.gov.pl","wios.gov.pl","witd.gov.pl","wzmiuw.gov.pl","piw.gov.pl","wiw.gov.pl","griw.gov.pl","wif.gov.pl","oum.gov.pl","sdn.gov.pl","zp.gov.pl","uppo.gov.pl","mup.gov.pl","wuoz.gov.pl","konsulat.gov.pl","oirm.gov.pl","augustow.pl","babia-gora.pl","bedzin.pl","beskidy.pl","bialowieza.pl","bialystok.pl","bielawa.pl","bieszczady.pl","boleslawiec.pl","bydgoszcz.pl","bytom.pl","cieszyn.pl","czeladz.pl","czest.pl","dlugoleka.pl","elblag.pl","elk.pl","glogow.pl","gniezno.pl","gorlice.pl","grajewo.pl","ilawa.pl","jaworzno.pl","jelenia-gora.pl","jgora.pl","kalisz.pl","kazimierz-dolny.pl","karpacz.pl","kartuzy.pl","kaszuby.pl","katowice.pl","kepno.pl","ketrzyn.pl","klodzko.pl","kobierzyce.pl","kolobrzeg.pl","konin.pl","konskowola.pl","kutno.pl","lapy.pl","lebork.pl","legnica.pl","lezajsk.pl","limanowa.pl","lomza.pl","lowicz.pl","lubin.pl","lukow.pl","malbork.pl","malopolska.pl","mazowsze.pl","mazury.pl","mielec.pl","mielno.pl","mragowo.pl","naklo.pl","nowaruda.pl","nysa.pl","olawa.pl","olecko.pl","olkusz.pl","olsztyn.pl","opoczno.pl","opole.pl","ostroda.pl","ostroleka.pl","ostrowiec.pl","ostrowwlkp.pl","pila.pl","pisz.pl","podhale.pl","podlasie.pl","polkowice.pl","pomorze.pl","pomorskie.pl","prochowice.pl","pruszkow.pl","przeworsk.pl","pulawy.pl","radom.pl","rawa-maz.pl","rybnik.pl","rzeszow.pl","sanok.pl","sejny.pl","slask.pl","slupsk.pl","sosnowiec.pl","stalowa-wola.pl","skoczow.pl","starachowice.pl","stargard.pl","suwalki.pl","swidnica.pl","swiebodzin.pl","swinoujscie.pl","szczecin.pl","szczytno.pl","tarnobrzeg.pl","tgory.pl","turek.pl","tychy.pl","ustka.pl","walbrzych.pl","warmia.pl","warszawa.pl","waw.pl","wegrow.pl","wielun.pl","wlocl.pl","wloclawek.pl","wodzislaw.pl","wolomin.pl","wroclaw.pl","zachpomor.pl","zagan.pl","zarow.pl","zgora.pl","zgorzelec.pl","pm","pn","gov.pn","co.pn","org.pn","edu.pn","net.pn","post","pr","com.pr","net.pr","org.pr","gov.pr","edu.pr","isla.pr","pro.pr","biz.pr","info.pr","name.pr","est.pr","prof.pr","ac.pr","pro","aaa.pro","aca.pro","acct.pro","avocat.pro","bar.pro","cpa.pro","eng.pro","jur.pro","law.pro","med.pro","recht.pro","ps","edu.ps","gov.ps","sec.ps","plo.ps","com.ps","org.ps","net.ps","pt","net.pt","gov.pt","org.pt","edu.pt","int.pt","publ.pt","com.pt","nome.pt","pw","co.pw","ne.pw","or.pw","ed.pw","go.pw","belau.pw","py","com.py","coop.py","edu.py","gov.py","mil.py","net.py","org.py","qa","com.qa","edu.qa","gov.qa","mil.qa","name.qa","net.qa","org.qa","sch.qa","re","asso.re","com.re","nom.re","ro","arts.ro","com.ro","firm.ro","info.ro","nom.ro","nt.ro","org.ro","rec.ro","store.ro","tm.ro","www.ro","rs","ac.rs","co.rs","edu.rs","gov.rs","in.rs","org.rs","ru","rw","ac.rw","co.rw","coop.rw","gov.rw","mil.rw","net.rw","org.rw","sa","com.sa","net.sa","org.sa","gov.sa","med.sa","pub.sa","edu.sa","sch.sa","sb","com.sb","edu.sb","gov.sb","net.sb","org.sb","sc","com.sc","gov.sc","net.sc","org.sc","edu.sc","sd","com.sd","net.sd","org.sd","edu.sd","med.sd","tv.sd","gov.sd","info.sd","se","a.se","ac.se","b.se","bd.se","brand.se","c.se","d.se","e.se","f.se","fh.se","fhsk.se","fhv.se","g.se","h.se","i.se","k.se","komforb.se","kommunalforbund.se","komvux.se","l.se","lanbib.se","m.se","n.se","naturbruksgymn.se","o.se","org.se","p.se","parti.se","pp.se","press.se","r.se","s.se","t.se","tm.se","u.se","w.se","x.se","y.se","z.se","sg","com.sg","net.sg","org.sg","gov.sg","edu.sg","per.sg","sh","com.sh","net.sh","gov.sh","org.sh","mil.sh","si","sj","sk","sl","com.sl","net.sl","edu.sl","gov.sl","org.sl","sm","sn","art.sn","com.sn","edu.sn","gouv.sn","org.sn","perso.sn","univ.sn","so","com.so","edu.so","gov.so","me.so","net.so","org.so","sr","ss","biz.ss","com.ss","edu.ss","gov.ss","net.ss","org.ss","st","co.st","com.st","consulado.st","edu.st","embaixada.st","gov.st","mil.st","net.st","org.st","principe.st","saotome.st","store.st","su","sv","com.sv","edu.sv","gob.sv","org.sv","red.sv","sx","gov.sx","sy","edu.sy","gov.sy","net.sy","mil.sy","com.sy","org.sy","sz","co.sz","ac.sz","org.sz","tc","td","tel","tf","tg","th","ac.th","co.th","go.th","in.th","mi.th","net.th","or.th","tj","ac.tj","biz.tj","co.tj","com.tj","edu.tj","go.tj","gov.tj","int.tj","mil.tj","name.tj","net.tj","nic.tj","org.tj","test.tj","web.tj","tk","tl","gov.tl","tm","com.tm","co.tm","org.tm","net.tm","nom.tm","gov.tm","mil.tm","edu.tm","tn","com.tn","ens.tn","fin.tn","gov.tn","ind.tn","intl.tn","nat.tn","net.tn","org.tn","info.tn","perso.tn","tourism.tn","edunet.tn","rnrt.tn","rns.tn","rnu.tn","mincom.tn","agrinet.tn","defense.tn","turen.tn","to","com.to","gov.to","net.to","org.to","edu.to","mil.to","tr","av.tr","bbs.tr","bel.tr","biz.tr","com.tr","dr.tr","edu.tr","gen.tr","gov.tr","info.tr","mil.tr","k12.tr","kep.tr","name.tr","net.tr","org.tr","pol.tr","tel.tr","tsk.tr","tv.tr","web.tr","nc.tr","gov.nc.tr","tt","co.tt","com.tt","org.tt","net.tt","biz.tt","info.tt","pro.tt","int.tt","coop.tt","jobs.tt","mobi.tt","travel.tt","museum.tt","aero.tt","name.tt","gov.tt","edu.tt","tv","tw","edu.tw","gov.tw","mil.tw","com.tw","net.tw","org.tw","idv.tw","game.tw","ebiz.tw","club.tw","網路.tw","組織.tw","商業.tw","tz","ac.tz","co.tz","go.tz","hotel.tz","info.tz","me.tz","mil.tz","mobi.tz","ne.tz","or.tz","sc.tz","tv.tz","ua","com.ua","edu.ua","gov.ua","in.ua","net.ua","org.ua","cherkassy.ua","cherkasy.ua","chernigov.ua","chernihiv.ua","chernivtsi.ua","chernovtsy.ua","ck.ua","cn.ua","cr.ua","crimea.ua","cv.ua","dn.ua","dnepropetrovsk.ua","dnipropetrovsk.ua","dominic.ua","donetsk.ua","dp.ua","if.ua","ivano-frankivsk.ua","kh.ua","kharkiv.ua","kharkov.ua","kherson.ua","khmelnitskiy.ua","khmelnytskyi.ua","kiev.ua","kirovograd.ua","km.ua","kr.ua","krym.ua","ks.ua","kv.ua","kyiv.ua","lg.ua","lt.ua","lugansk.ua","lutsk.ua","lv.ua","lviv.ua","mk.ua","mykolaiv.ua","nikolaev.ua","od.ua","odesa.ua","odessa.ua","pl.ua","poltava.ua","rivne.ua","rovno.ua","rv.ua","sb.ua","sebastopol.ua","sevastopol.ua","sm.ua","sumy.ua","te.ua","ternopil.ua","uz.ua","uzhgorod.ua","vinnica.ua","vinnytsia.ua","vn.ua","volyn.ua","yalta.ua","zaporizhzhe.ua","zaporizhzhia.ua","zhitomir.ua","zhytomyr.ua","zp.ua","zt.ua","ug","co.ug","or.ug","ac.ug","sc.ug","go.ug","ne.ug","com.ug","org.ug","uk","ac.uk","co.uk","gov.uk","ltd.uk","me.uk","net.uk","nhs.uk","org.uk","plc.uk","police.uk","*.sch.uk","us","dni.us","fed.us","isa.us","kids.us","nsn.us","ak.us","al.us","ar.us","as.us","az.us","ca.us","co.us","ct.us","dc.us","de.us","fl.us","ga.us","gu.us","hi.us","ia.us","id.us","il.us","in.us","ks.us","ky.us","la.us","ma.us","md.us","me.us","mi.us","mn.us","mo.us","ms.us","mt.us","nc.us","nd.us","ne.us","nh.us","nj.us","nm.us","nv.us","ny.us","oh.us","ok.us","or.us","pa.us","pr.us","ri.us","sc.us","sd.us","tn.us","tx.us","ut.us","vi.us","vt.us","va.us","wa.us","wi.us","wv.us","wy.us","k12.ak.us","k12.al.us","k12.ar.us","k12.as.us","k12.az.us","k12.ca.us","k12.co.us","k12.ct.us","k12.dc.us","k12.de.us","k12.fl.us","k12.ga.us","k12.gu.us","k12.ia.us","k12.id.us","k12.il.us","k12.in.us","k12.ks.us","k12.ky.us","k12.la.us","k12.ma.us","k12.md.us","k12.me.us","k12.mi.us","k12.mn.us","k12.mo.us","k12.ms.us","k12.mt.us","k12.nc.us","k12.ne.us","k12.nh.us","k12.nj.us","k12.nm.us","k12.nv.us","k12.ny.us","k12.oh.us","k12.ok.us","k12.or.us","k12.pa.us","k12.pr.us","k12.ri.us","k12.sc.us","k12.tn.us","k12.tx.us","k12.ut.us","k12.vi.us","k12.vt.us","k12.va.us","k12.wa.us","k12.wi.us","k12.wy.us","cc.ak.us","cc.al.us","cc.ar.us","cc.as.us","cc.az.us","cc.ca.us","cc.co.us","cc.ct.us","cc.dc.us","cc.de.us","cc.fl.us","cc.ga.us","cc.gu.us","cc.hi.us","cc.ia.us","cc.id.us","cc.il.us","cc.in.us","cc.ks.us","cc.ky.us","cc.la.us","cc.ma.us","cc.md.us","cc.me.us","cc.mi.us","cc.mn.us","cc.mo.us","cc.ms.us","cc.mt.us","cc.nc.us","cc.nd.us","cc.ne.us","cc.nh.us","cc.nj.us","cc.nm.us","cc.nv.us","cc.ny.us","cc.oh.us","cc.ok.us","cc.or.us","cc.pa.us","cc.pr.us","cc.ri.us","cc.sc.us","cc.sd.us","cc.tn.us","cc.tx.us","cc.ut.us","cc.vi.us","cc.vt.us","cc.va.us","cc.wa.us","cc.wi.us","cc.wv.us","cc.wy.us","lib.ak.us","lib.al.us","lib.ar.us","lib.as.us","lib.az.us","lib.ca.us","lib.co.us","lib.ct.us","lib.dc.us","lib.fl.us","lib.ga.us","lib.gu.us","lib.hi.us","lib.ia.us","lib.id.us","lib.il.us","lib.in.us","lib.ks.us","lib.ky.us","lib.la.us","lib.ma.us","lib.md.us","lib.me.us","lib.mi.us","lib.mn.us","lib.mo.us","lib.ms.us","lib.mt.us","lib.nc.us","lib.nd.us","lib.ne.us","lib.nh.us","lib.nj.us","lib.nm.us","lib.nv.us","lib.ny.us","lib.oh.us","lib.ok.us","lib.or.us","lib.pa.us","lib.pr.us","lib.ri.us","lib.sc.us","lib.sd.us","lib.tn.us","lib.tx.us","lib.ut.us","lib.vi.us","lib.vt.us","lib.va.us","lib.wa.us","lib.wi.us","lib.wy.us","pvt.k12.ma.us","chtr.k12.ma.us","paroch.k12.ma.us","ann-arbor.mi.us","cog.mi.us","dst.mi.us","eaton.mi.us","gen.mi.us","mus.mi.us","tec.mi.us","washtenaw.mi.us","uy","com.uy","edu.uy","gub.uy","mil.uy","net.uy","org.uy","uz","co.uz","com.uz","net.uz","org.uz","va","vc","com.vc","net.vc","org.vc","gov.vc","mil.vc","edu.vc","ve","arts.ve","co.ve","com.ve","e12.ve","edu.ve","firm.ve","gob.ve","gov.ve","info.ve","int.ve","mil.ve","net.ve","org.ve","rec.ve","store.ve","tec.ve","web.ve","vg","vi","co.vi","com.vi","k12.vi","net.vi","org.vi","vn","com.vn","net.vn","org.vn","edu.vn","gov.vn","int.vn","ac.vn","biz.vn","info.vn","name.vn","pro.vn","health.vn","vu","com.vu","edu.vu","net.vu","org.vu","wf","ws","com.ws","net.ws","org.ws","gov.ws","edu.ws","yt","امارات","հայ","বাংলা","бг","бел","中国","中國","الجزائر","مصر","ею","ευ","موريتانيا","გე","ελ","香港","公司.香港","教育.香港","政府.香港","個人.香港","網絡.香港","組織.香港","ಭಾರತ","ଭାରତ","ভাৰত","भारतम्","भारोत","ڀارت","ഭാരതം","भारत","بارت","بھارت","భారత్","ભારત","ਭਾਰਤ","ভারত","இந்தியா","ایران","ايران","عراق","الاردن","한국","қаз","ලංකා","இலங்கை","المغرب","мкд","мон","澳門","澳门","مليسيا","عمان","پاکستان","پاكستان","فلسطين","срб","пр.срб","орг.срб","обр.срб","од.срб","упр.срб","ак.срб","рф","قطر","السعودية","السعودیة","السعودیۃ","السعوديه","سودان","新加坡","சிங்கப்பூர்","سورية","سوريا","ไทย","ศึกษา.ไทย","ธุรกิจ.ไทย","รัฐบาล.ไทย","ทหาร.ไทย","เน็ต.ไทย","องค์กร.ไทย","تونس","台灣","台湾","臺灣","укр","اليمن","xxx","*.ye","ac.za","agric.za","alt.za","co.za","edu.za","gov.za","grondar.za","law.za","mil.za","net.za","ngo.za","nic.za","nis.za","nom.za","org.za","school.za","tm.za","web.za","zm","ac.zm","biz.zm","co.zm","com.zm","edu.zm","gov.zm","info.zm","mil.zm","net.zm","org.zm","sch.zm","zw","ac.zw","co.zw","gov.zw","mil.zw","org.zw","aaa","aarp","abarth","abb","abbott","abbvie","abc","able","abogado","abudhabi","academy","accenture","accountant","accountants","aco","actor","adac","ads","adult","aeg","aetna","afamilycompany","afl","africa","agakhan","agency","aig","aigo","airbus","airforce","airtel","akdn","alfaromeo","alibaba","alipay","allfinanz","allstate","ally","alsace","alstom","amazon","americanexpress","americanfamily","amex","amfam","amica","amsterdam","analytics","android","anquan","anz","aol","apartments","app","apple","aquarelle","arab","aramco","archi","army","art","arte","asda","associates","athleta","attorney","auction","audi","audible","audio","auspost","author","auto","autos","avianca","aws","axa","azure","baby","baidu","banamex","bananarepublic","band","bank","bar","barcelona","barclaycard","barclays","barefoot","bargains","baseball","basketball","bauhaus","bayern","bbc","bbt","bbva","bcg","bcn","beats","beauty","beer","bentley","berlin","best","bestbuy","bet","bharti","bible","bid","bike","bing","bingo","bio","black","blackfriday","blockbuster","blog","bloomberg","blue","bms","bmw","bnpparibas","boats","boehringer","bofa","bom","bond","boo","book","booking","bosch","bostik","boston","bot","boutique","box","bradesco","bridgestone","broadway","broker","brother","brussels","budapest","bugatti","build","builders","business","buy","buzz","bzh","cab","cafe","cal","call","calvinklein","cam","camera","camp","cancerresearch","canon","capetown","capital","capitalone","car","caravan","cards","care","career","careers","cars","casa","case","caseih","cash","casino","catering","catholic","cba","cbn","cbre","cbs","ceb","center","ceo","cern","cfa","cfd","chanel","channel","charity","chase","chat","cheap","chintai","christmas","chrome","church","cipriani","circle","cisco","citadel","citi","citic","city","cityeats","claims","cleaning","click","clinic","clinique","clothing","cloud","club","clubmed","coach","codes","coffee","college","cologne","comcast","commbank","community","company","compare","computer","comsec","condos","construction","consulting","contact","contractors","cooking","cookingchannel","cool","corsica","country","coupon","coupons","courses","cpa","credit","creditcard","creditunion","cricket","crown","crs","cruise","cruises","csc","cuisinella","cymru","cyou","dabur","dad","dance","data","date","dating","datsun","day","dclk","dds","deal","dealer","deals","degree","delivery","dell","deloitte","delta","democrat","dental","dentist","desi","design","dev","dhl","diamonds","diet","digital","direct","directory","discount","discover","dish","diy","dnp","docs","doctor","dog","domains","dot","download","drive","dtv","dubai","duck","dunlop","dupont","durban","dvag","dvr","earth","eat","eco","edeka","education","email","emerck","energy","engineer","engineering","enterprises","epson","equipment","ericsson","erni","esq","estate","esurance","etisalat","eurovision","eus","events","exchange","expert","exposed","express","extraspace","fage","fail","fairwinds","faith","family","fan","fans","farm","farmers","fashion","fast","fedex","feedback","ferrari","ferrero","fiat","fidelity","fido","film","final","finance","financial","fire","firestone","firmdale","fish","fishing","fit","fitness","flickr","flights","flir","florist","flowers","fly","foo","food","foodnetwork","football","ford","forex","forsale","forum","foundation","fox","free","fresenius","frl","frogans","frontdoor","frontier","ftr","fujitsu","fujixerox","fun","fund","furniture","futbol","fyi","gal","gallery","gallo","gallup","game","games","gap","garden","gay","gbiz","gdn","gea","gent","genting","george","ggee","gift","gifts","gives","giving","glade","glass","gle","global","globo","gmail","gmbh","gmo","gmx","godaddy","gold","goldpoint","golf","goo","goodyear","goog","google","gop","got","grainger","graphics","gratis","green","gripe","grocery","group","guardian","gucci","guge","guide","guitars","guru","hair","hamburg","hangout","haus","hbo","hdfc","hdfcbank","health","healthcare","help","helsinki","here","hermes","hgtv","hiphop","hisamitsu","hitachi","hiv","hkt","hockey","holdings","holiday","homedepot","homegoods","homes","homesense","honda","horse","hospital","host","hosting","hot","hoteles","hotels","hotmail","house","how","hsbc","hughes","hyatt","hyundai","ibm","icbc","ice","icu","ieee","ifm","ikano","imamat","imdb","immo","immobilien","inc","industries","infiniti","ing","ink","institute","insurance","insure","intel","international","intuit","investments","ipiranga","irish","ismaili","ist","istanbul","itau","itv","iveco","jaguar","java","jcb","jcp","jeep","jetzt","jewelry","jio","jll","jmp","jnj","joburg","jot","joy","jpmorgan","jprs","juegos","juniper","kaufen","kddi","kerryhotels","kerrylogistics","kerryproperties","kfh","kia","kim","kinder","kindle","kitchen","kiwi","koeln","komatsu","kosher","kpmg","kpn","krd","kred","kuokgroup","kyoto","lacaixa","lamborghini","lamer","lancaster","lancia","land","landrover","lanxess","lasalle","lat","latino","latrobe","law","lawyer","lds","lease","leclerc","lefrak","legal","lego","lexus","lgbt","lidl","life","lifeinsurance","lifestyle","lighting","like","lilly","limited","limo","lincoln","linde","link","lipsy","live","living","lixil","llc","llp","loan","loans","locker","locus","loft","lol","london","lotte","lotto","love","lpl","lplfinancial","ltd","ltda","lundbeck","lupin","luxe","luxury","macys","madrid","maif","maison","makeup","man","management","mango","map","market","marketing","markets","marriott","marshalls","maserati","mattel","mba","mckinsey","med","media","meet","melbourne","meme","memorial","men","menu","merckmsd","metlife","miami","microsoft","mini","mint","mit","mitsubishi","mlb","mls","mma","mobile","moda","moe","moi","mom","monash","money","monster","mormon","mortgage","moscow","moto","motorcycles","mov","movie","msd","mtn","mtr","mutual","nab","nadex","nagoya","nationwide","natura","navy","nba","nec","netbank","netflix","network","neustar","new","newholland","news","next","nextdirect","nexus","nfl","ngo","nhk","nico","nike","nikon","ninja","nissan","nissay","nokia","northwesternmutual","norton","now","nowruz","nowtv","nra","nrw","ntt","nyc","obi","observer","off","office","okinawa","olayan","olayangroup","oldnavy","ollo","omega","one","ong","onl","online","onyourside","ooo","open","oracle","orange","organic","origins","osaka","otsuka","ott","ovh","page","panasonic","paris","pars","partners","parts","party","passagens","pay","pccw","pet","pfizer","pharmacy","phd","philips","phone","photo","photography","photos","physio","pics","pictet","pictures","pid","pin","ping","pink","pioneer","pizza","place","play","playstation","plumbing","plus","pnc","pohl","poker","politie","porn","pramerica","praxi","press","prime","prod","productions","prof","progressive","promo","properties","property","protection","pru","prudential","pub","pwc","qpon","quebec","quest","qvc","racing","radio","raid","read","realestate","realtor","realty","recipes","red","redstone","redumbrella","rehab","reise","reisen","reit","reliance","ren","rent","rentals","repair","report","republican","rest","restaurant","review","reviews","rexroth","rich","richardli","ricoh","rightathome","ril","rio","rip","rmit","rocher","rocks","rodeo","rogers","room","rsvp","rugby","ruhr","run","rwe","ryukyu","saarland","safe","safety","sakura","sale","salon","samsclub","samsung","sandvik","sandvikcoromant","sanofi","sap","sarl","sas","save","saxo","sbi","sbs","sca","scb","schaeffler","schmidt","scholarships","school","schule","schwarz","science","scjohnson","scor","scot","search","seat","secure","security","seek","select","sener","services","ses","seven","sew","sex","sexy","sfr","shangrila","sharp","shaw","shell","shia","shiksha","shoes","shop","shopping","shouji","show","showtime","shriram","silk","sina","singles","site","ski","skin","sky","skype","sling","smart","smile","sncf","soccer","social","softbank","software","sohu","solar","solutions","song","sony","soy","spa","space","sport","spot","spreadbetting","srl","stada","staples","star","statebank","statefarm","stc","stcgroup","stockholm","storage","store","stream","studio","study","style","sucks","supplies","supply","support","surf","surgery","suzuki","swatch","swiftcover","swiss","sydney","symantec","systems","tab","taipei","talk","taobao","target","tatamotors","tatar","tattoo","tax","taxi","tci","tdk","team","tech","technology","temasek","tennis","teva","thd","theater","theatre","tiaa","tickets","tienda","tiffany","tips","tires","tirol","tjmaxx","tjx","tkmaxx","tmall","today","tokyo","tools","top","toray","toshiba","total","tours","town","toyota","toys","trade","trading","training","travel","travelchannel","travelers","travelersinsurance","trust","trv","tube","tui","tunes","tushu","tvs","ubank","ubs","unicom","university","uno","uol","ups","vacations","vana","vanguard","vegas","ventures","verisign","versicherung","vet","viajes","video","vig","viking","villas","vin","vip","virgin","visa","vision","viva","vivo","vlaanderen","vodka","volkswagen","volvo","vote","voting","voto","voyage","vuelos","wales","walmart","walter","wang","wanggou","watch","watches","weather","weatherchannel","webcam","weber","website","wed","wedding","weibo","weir","whoswho","wien","wiki","williamhill","win","windows","wine","winners","wme","wolterskluwer","woodside","work","works","world","wow","wtc","wtf","xbox","xerox","xfinity","xihuan","xin","कॉम","セール","佛山","慈善","集团","在线","大众汽车","点看","คอม","八卦","موقع","公益","公司","香格里拉","网站","移动","我爱你","москва","католик","онлайн","сайт","联通","קום","时尚","微博","淡马锡","ファッション","орг","नेट","ストア","アマゾン","삼성","商标","商店","商城","дети","ポイント","新闻","工行","家電","كوم","中文网","中信","娱乐","谷歌","電訊盈科","购物","クラウド","通販","网店","संगठन","餐厅","网络","ком","亚马逊","诺基亚","食品","飞利浦","手表","手机","ارامكو","العليان","اتصالات","بازار","ابوظبي","كاثوليك","همراه","닷컴","政府","شبكة","بيتك","عرب","机构","组织机构","健康","招聘","рус","珠宝","大拿","みんな","グーグル","世界","書籍","网址","닷넷","コム","天主教","游戏","vermögensberater","vermögensberatung","企业","信息","嘉里大酒店","嘉里","广东","政务","xyz","yachts","yahoo","yamaxun","yandex","yodobashi","yoga","yokohama","you","youtube","yun","zappos","zara","zero","zip","zone","zuerich","cc.ua","inf.ua","ltd.ua","adobeaemcloud.com","adobeaemcloud.net","*.dev.adobeaemcloud.com","beep.pl","barsy.ca","*.compute.estate","*.alces.network","altervista.org","alwaysdata.net","cloudfront.net","*.compute.amazonaws.com","*.compute-1.amazonaws.com","*.compute.amazonaws.com.cn","us-east-1.amazonaws.com","cn-north-1.eb.amazonaws.com.cn","cn-northwest-1.eb.amazonaws.com.cn","elasticbeanstalk.com","ap-northeast-1.elasticbeanstalk.com","ap-northeast-2.elasticbeanstalk.com","ap-northeast-3.elasticbeanstalk.com","ap-south-1.elasticbeanstalk.com","ap-southeast-1.elasticbeanstalk.com","ap-southeast-2.elasticbeanstalk.com","ca-central-1.elasticbeanstalk.com","eu-central-1.elasticbeanstalk.com","eu-west-1.elasticbeanstalk.com","eu-west-2.elasticbeanstalk.com","eu-west-3.elasticbeanstalk.com","sa-east-1.elasticbeanstalk.com","us-east-1.elasticbeanstalk.com","us-east-2.elasticbeanstalk.com","us-gov-west-1.elasticbeanstalk.com","us-west-1.elasticbeanstalk.com","us-west-2.elasticbeanstalk.com","*.elb.amazonaws.com","*.elb.amazonaws.com.cn","s3.amazonaws.com","s3-ap-northeast-1.amazonaws.com","s3-ap-northeast-2.amazonaws.com","s3-ap-south-1.amazonaws.com","s3-ap-southeast-1.amazonaws.com","s3-ap-southeast-2.amazonaws.com","s3-ca-central-1.amazonaws.com","s3-eu-central-1.amazonaws.com","s3-eu-west-1.amazonaws.com","s3-eu-west-2.amazonaws.com","s3-eu-west-3.amazonaws.com","s3-external-1.amazonaws.com","s3-fips-us-gov-west-1.amazonaws.com","s3-sa-east-1.amazonaws.com","s3-us-gov-west-1.amazonaws.com","s3-us-east-2.amazonaws.com","s3-us-west-1.amazonaws.com","s3-us-west-2.amazonaws.com","s3.ap-northeast-2.amazonaws.com","s3.ap-south-1.amazonaws.com","s3.cn-north-1.amazonaws.com.cn","s3.ca-central-1.amazonaws.com","s3.eu-central-1.amazonaws.com","s3.eu-west-2.amazonaws.com","s3.eu-west-3.amazonaws.com","s3.us-east-2.amazonaws.com","s3.dualstack.ap-northeast-1.amazonaws.com","s3.dualstack.ap-northeast-2.amazonaws.com","s3.dualstack.ap-south-1.amazonaws.com","s3.dualstack.ap-southeast-1.amazonaws.com","s3.dualstack.ap-southeast-2.amazonaws.com","s3.dualstack.ca-central-1.amazonaws.com","s3.dualstack.eu-central-1.amazonaws.com","s3.dualstack.eu-west-1.amazonaws.com","s3.dualstack.eu-west-2.amazonaws.com","s3.dualstack.eu-west-3.amazonaws.com","s3.dualstack.sa-east-1.amazonaws.com","s3.dualstack.us-east-1.amazonaws.com","s3.dualstack.us-east-2.amazonaws.com","s3-website-us-east-1.amazonaws.com","s3-website-us-west-1.amazonaws.com","s3-website-us-west-2.amazonaws.com","s3-website-ap-northeast-1.amazonaws.com","s3-website-ap-southeast-1.amazonaws.com","s3-website-ap-southeast-2.amazonaws.com","s3-website-eu-west-1.amazonaws.com","s3-website-sa-east-1.amazonaws.com","s3-website.ap-northeast-2.amazonaws.com","s3-website.ap-south-1.amazonaws.com","s3-website.ca-central-1.amazonaws.com","s3-website.eu-central-1.amazonaws.com","s3-website.eu-west-2.amazonaws.com","s3-website.eu-west-3.amazonaws.com","s3-website.us-east-2.amazonaws.com","amsw.nl","t3l3p0rt.net","tele.amune.org","apigee.io","on-aptible.com","user.aseinet.ne.jp","gv.vc","d.gv.vc","user.party.eus","pimienta.org","poivron.org","potager.org","sweetpepper.org","myasustor.com","myfritz.net","*.awdev.ca","*.advisor.ws","b-data.io","backplaneapp.io","balena-devices.com","app.banzaicloud.io","betainabox.com","bnr.la","blackbaudcdn.net","boomla.net","boxfuse.io","square7.ch","bplaced.com","bplaced.de","square7.de","bplaced.net","square7.net","browsersafetymark.io","uk0.bigv.io","dh.bytemark.co.uk","vm.bytemark.co.uk","mycd.eu","carrd.co","crd.co","uwu.ai","ae.org","ar.com","br.com","cn.com","com.de","com.se","de.com","eu.com","gb.com","gb.net","hu.com","hu.net","jp.net","jpn.com","kr.com","mex.com","no.com","qc.com","ru.com","sa.com","se.net","uk.com","uk.net","us.com","uy.com","za.bz","za.com","africa.com","gr.com","in.net","us.org","co.com","c.la","certmgr.org","xenapponazure.com","discourse.group","discourse.team","virtueeldomein.nl","cleverapps.io","*.lcl.dev","*.stg.dev","c66.me","cloud66.ws","cloud66.zone","jdevcloud.com","wpdevcloud.com","cloudaccess.host","freesite.host","cloudaccess.net","cloudcontrolled.com","cloudcontrolapp.com","cloudera.site","trycloudflare.com","workers.dev","wnext.app","co.ca","*.otap.co","co.cz","c.cdn77.org","cdn77-ssl.net","r.cdn77.net","rsc.cdn77.org","ssl.origin.cdn77-secure.org","cloudns.asia","cloudns.biz","cloudns.club","cloudns.cc","cloudns.eu","cloudns.in","cloudns.info","cloudns.org","cloudns.pro","cloudns.pw","cloudns.us","cloudeity.net","cnpy.gdn","co.nl","co.no","webhosting.be","hosting-cluster.nl","ac.ru","edu.ru","gov.ru","int.ru","mil.ru","test.ru","dyn.cosidns.de","dynamisches-dns.de","dnsupdater.de","internet-dns.de","l-o-g-i-n.de","dynamic-dns.info","feste-ip.net","knx-server.net","static-access.net","realm.cz","*.cryptonomic.net","cupcake.is","*.customer-oci.com","*.oci.customer-oci.com","*.ocp.customer-oci.com","*.ocs.customer-oci.com","cyon.link","cyon.site","daplie.me","localhost.daplie.me","dattolocal.com","dattorelay.com","dattoweb.com","mydatto.com","dattolocal.net","mydatto.net","biz.dk","co.dk","firm.dk","reg.dk","store.dk","*.dapps.earth","*.bzz.dapps.earth","builtwithdark.com","edgestack.me","debian.net","dedyn.io","dnshome.de","online.th","shop.th","drayddns.com","dreamhosters.com","mydrobo.com","drud.io","drud.us","duckdns.org","dy.fi","tunk.org","dyndns-at-home.com","dyndns-at-work.com","dyndns-blog.com","dyndns-free.com","dyndns-home.com","dyndns-ip.com","dyndns-mail.com","dyndns-office.com","dyndns-pics.com","dyndns-remote.com","dyndns-server.com","dyndns-web.com","dyndns-wiki.com","dyndns-work.com","dyndns.biz","dyndns.info","dyndns.org","dyndns.tv","at-band-camp.net","ath.cx","barrel-of-knowledge.info","barrell-of-knowledge.info","better-than.tv","blogdns.com","blogdns.net","blogdns.org","blogsite.org","boldlygoingnowhere.org","broke-it.net","buyshouses.net","cechire.com","dnsalias.com","dnsalias.net","dnsalias.org","dnsdojo.com","dnsdojo.net","dnsdojo.org","does-it.net","doesntexist.com","doesntexist.org","dontexist.com","dontexist.net","dontexist.org","doomdns.com","doomdns.org","dvrdns.org","dyn-o-saur.com","dynalias.com","dynalias.net","dynalias.org","dynathome.net","dyndns.ws","endofinternet.net","endofinternet.org","endoftheinternet.org","est-a-la-maison.com","est-a-la-masion.com","est-le-patron.com","est-mon-blogueur.com","for-better.biz","for-more.biz","for-our.info","for-some.biz","for-the.biz","forgot.her.name","forgot.his.name","from-ak.com","from-al.com","from-ar.com","from-az.net","from-ca.com","from-co.net","from-ct.com","from-dc.com","from-de.com","from-fl.com","from-ga.com","from-hi.com","from-ia.com","from-id.com","from-il.com","from-in.com","from-ks.com","from-ky.com","from-la.net","from-ma.com","from-md.com","from-me.org","from-mi.com","from-mn.com","from-mo.com","from-ms.com","from-mt.com","from-nc.com","from-nd.com","from-ne.com","from-nh.com","from-nj.com","from-nm.com","from-nv.com","from-ny.net","from-oh.com","from-ok.com","from-or.com","from-pa.com","from-pr.com","from-ri.com","from-sc.com","from-sd.com","from-tn.com","from-tx.com","from-ut.com","from-va.com","from-vt.com","from-wa.com","from-wi.com","from-wv.com","from-wy.com","ftpaccess.cc","fuettertdasnetz.de","game-host.org","game-server.cc","getmyip.com","gets-it.net","go.dyndns.org","gotdns.com","gotdns.org","groks-the.info","groks-this.info","ham-radio-op.net","here-for-more.info","hobby-site.com","hobby-site.org","home.dyndns.org","homedns.org","homeftp.net","homeftp.org","homeip.net","homelinux.com","homelinux.net","homelinux.org","homeunix.com","homeunix.net","homeunix.org","iamallama.com","in-the-band.net","is-a-anarchist.com","is-a-blogger.com","is-a-bookkeeper.com","is-a-bruinsfan.org","is-a-bulls-fan.com","is-a-candidate.org","is-a-caterer.com","is-a-celticsfan.org","is-a-chef.com","is-a-chef.net","is-a-chef.org","is-a-conservative.com","is-a-cpa.com","is-a-cubicle-slave.com","is-a-democrat.com","is-a-designer.com","is-a-doctor.com","is-a-financialadvisor.com","is-a-geek.com","is-a-geek.net","is-a-geek.org","is-a-green.com","is-a-guru.com","is-a-hard-worker.com","is-a-hunter.com","is-a-knight.org","is-a-landscaper.com","is-a-lawyer.com","is-a-liberal.com","is-a-libertarian.com","is-a-linux-user.org","is-a-llama.com","is-a-musician.com","is-a-nascarfan.com","is-a-nurse.com","is-a-painter.com","is-a-patsfan.org","is-a-personaltrainer.com","is-a-photographer.com","is-a-player.com","is-a-republican.com","is-a-rockstar.com","is-a-socialist.com","is-a-soxfan.org","is-a-student.com","is-a-teacher.com","is-a-techie.com","is-a-therapist.com","is-an-accountant.com","is-an-actor.com","is-an-actress.com","is-an-anarchist.com","is-an-artist.com","is-an-engineer.com","is-an-entertainer.com","is-by.us","is-certified.com","is-found.org","is-gone.com","is-into-anime.com","is-into-cars.com","is-into-cartoons.com","is-into-games.com","is-leet.com","is-lost.org","is-not-certified.com","is-saved.org","is-slick.com","is-uberleet.com","is-very-bad.org","is-very-evil.org","is-very-good.org","is-very-nice.org","is-very-sweet.org","is-with-theband.com","isa-geek.com","isa-geek.net","isa-geek.org","isa-hockeynut.com","issmarterthanyou.com","isteingeek.de","istmein.de","kicks-ass.net","kicks-ass.org","knowsitall.info","land-4-sale.us","lebtimnetz.de","leitungsen.de","likes-pie.com","likescandy.com","merseine.nu","mine.nu","misconfused.org","mypets.ws","myphotos.cc","neat-url.com","office-on-the.net","on-the-web.tv","podzone.net","podzone.org","readmyblog.org","saves-the-whales.com","scrapper-site.net","scrapping.cc","selfip.biz","selfip.com","selfip.info","selfip.net","selfip.org","sells-for-less.com","sells-for-u.com","sells-it.net","sellsyourhome.org","servebbs.com","servebbs.net","servebbs.org","serveftp.net","serveftp.org","servegame.org","shacknet.nu","simple-url.com","space-to-rent.com","stuff-4-sale.org","stuff-4-sale.us","teaches-yoga.com","thruhere.net","traeumtgerade.de","webhop.biz","webhop.info","webhop.net","webhop.org","worse-than.tv","writesthisblog.com","ddnss.de","dyn.ddnss.de","dyndns.ddnss.de","dyndns1.de","dyn-ip24.de","home-webserver.de","dyn.home-webserver.de","myhome-server.de","ddnss.org","definima.net","definima.io","bci.dnstrace.pro","ddnsfree.com","ddnsgeek.com","giize.com","gleeze.com","kozow.com","loseyourip.com","ooguy.com","theworkpc.com","casacam.net","dynu.net","accesscam.org","camdvr.org","freeddns.org","mywire.org","webredirect.org","myddns.rocks","blogsite.xyz","dynv6.net","e4.cz","en-root.fr","mytuleap.com","onred.one","staging.onred.one","enonic.io","customer.enonic.io","eu.org","al.eu.org","asso.eu.org","at.eu.org","au.eu.org","be.eu.org","bg.eu.org","ca.eu.org","cd.eu.org","ch.eu.org","cn.eu.org","cy.eu.org","cz.eu.org","de.eu.org","dk.eu.org","edu.eu.org","ee.eu.org","es.eu.org","fi.eu.org","fr.eu.org","gr.eu.org","hr.eu.org","hu.eu.org","ie.eu.org","il.eu.org","in.eu.org","int.eu.org","is.eu.org","it.eu.org","jp.eu.org","kr.eu.org","lt.eu.org","lu.eu.org","lv.eu.org","mc.eu.org","me.eu.org","mk.eu.org","mt.eu.org","my.eu.org","net.eu.org","ng.eu.org","nl.eu.org","no.eu.org","nz.eu.org","paris.eu.org","pl.eu.org","pt.eu.org","q-a.eu.org","ro.eu.org","ru.eu.org","se.eu.org","si.eu.org","sk.eu.org","tr.eu.org","uk.eu.org","us.eu.org","eu-1.evennode.com","eu-2.evennode.com","eu-3.evennode.com","eu-4.evennode.com","us-1.evennode.com","us-2.evennode.com","us-3.evennode.com","us-4.evennode.com","twmail.cc","twmail.net","twmail.org","mymailer.com.tw","url.tw","apps.fbsbx.com","ru.net","adygeya.ru","bashkiria.ru","bir.ru","cbg.ru","com.ru","dagestan.ru","grozny.ru","kalmykia.ru","kustanai.ru","marine.ru","mordovia.ru","msk.ru","mytis.ru","nalchik.ru","nov.ru","pyatigorsk.ru","spb.ru","vladikavkaz.ru","vladimir.ru","abkhazia.su","adygeya.su","aktyubinsk.su","arkhangelsk.su","armenia.su","ashgabad.su","azerbaijan.su","balashov.su","bashkiria.su","bryansk.su","bukhara.su","chimkent.su","dagestan.su","east-kazakhstan.su","exnet.su","georgia.su","grozny.su","ivanovo.su","jambyl.su","kalmykia.su","kaluga.su","karacol.su","karaganda.su","karelia.su","khakassia.su","krasnodar.su","kurgan.su","kustanai.su","lenug.su","mangyshlak.su","mordovia.su","msk.su","murmansk.su","nalchik.su","navoi.su","north-kazakhstan.su","nov.su","obninsk.su","penza.su","pokrovsk.su","sochi.su","spb.su","tashkent.su","termez.su","togliatti.su","troitsk.su","tselinograd.su","tula.su","tuva.su","vladikavkaz.su","vladimir.su","vologda.su","channelsdvr.net","u.channelsdvr.net","fastly-terrarium.com","fastlylb.net","map.fastlylb.net","freetls.fastly.net","map.fastly.net","a.prod.fastly.net","global.prod.fastly.net","a.ssl.fastly.net","b.ssl.fastly.net","global.ssl.fastly.net","fastpanel.direct","fastvps-server.com","fhapp.xyz","fedorainfracloud.org","fedorapeople.org","cloud.fedoraproject.org","app.os.fedoraproject.org","app.os.stg.fedoraproject.org","mydobiss.com","filegear.me","filegear-au.me","filegear-de.me","filegear-gb.me","filegear-ie.me","filegear-jp.me","filegear-sg.me","firebaseapp.com","flynnhub.com","flynnhosting.net","0e.vc","freebox-os.com","freeboxos.com","fbx-os.fr","fbxos.fr","freebox-os.fr","freeboxos.fr","freedesktop.org","*.futurecms.at","*.ex.futurecms.at","*.in.futurecms.at","futurehosting.at","futuremailing.at","*.ex.ortsinfo.at","*.kunden.ortsinfo.at","*.statics.cloud","service.gov.uk","gehirn.ne.jp","usercontent.jp","gentapps.com","lab.ms","github.io","githubusercontent.com","gitlab.io","glitch.me","lolipop.io","cloudapps.digital","london.cloudapps.digital","homeoffice.gov.uk","ro.im","shop.ro","goip.de","run.app","a.run.app","web.app","*.0emm.com","appspot.com","*.r.appspot.com","blogspot.ae","blogspot.al","blogspot.am","blogspot.ba","blogspot.be","blogspot.bg","blogspot.bj","blogspot.ca","blogspot.cf","blogspot.ch","blogspot.cl","blogspot.co.at","blogspot.co.id","blogspot.co.il","blogspot.co.ke","blogspot.co.nz","blogspot.co.uk","blogspot.co.za","blogspot.com","blogspot.com.ar","blogspot.com.au","blogspot.com.br","blogspot.com.by","blogspot.com.co","blogspot.com.cy","blogspot.com.ee","blogspot.com.eg","blogspot.com.es","blogspot.com.mt","blogspot.com.ng","blogspot.com.tr","blogspot.com.uy","blogspot.cv","blogspot.cz","blogspot.de","blogspot.dk","blogspot.fi","blogspot.fr","blogspot.gr","blogspot.hk","blogspot.hr","blogspot.hu","blogspot.ie","blogspot.in","blogspot.is","blogspot.it","blogspot.jp","blogspot.kr","blogspot.li","blogspot.lt","blogspot.lu","blogspot.md","blogspot.mk","blogspot.mr","blogspot.mx","blogspot.my","blogspot.nl","blogspot.no","blogspot.pe","blogspot.pt","blogspot.qa","blogspot.re","blogspot.ro","blogspot.rs","blogspot.ru","blogspot.se","blogspot.sg","blogspot.si","blogspot.sk","blogspot.sn","blogspot.td","blogspot.tw","blogspot.ug","blogspot.vn","cloudfunctions.net","cloud.goog","codespot.com","googleapis.com","googlecode.com","pagespeedmobilizer.com","publishproxy.com","withgoogle.com","withyoutube.com","awsmppl.com","fin.ci","free.hr","caa.li","ua.rs","conf.se","hs.zone","hs.run","hashbang.sh","hasura.app","hasura-app.io","hepforge.org","herokuapp.com","herokussl.com","myravendb.com","ravendb.community","ravendb.me","development.run","ravendb.run","bpl.biz","orx.biz","ng.city","biz.gl","ng.ink","col.ng","firm.ng","gen.ng","ltd.ng","ngo.ng","ng.school","sch.so","häkkinen.fi","*.moonscale.io","moonscale.net","iki.fi","dyn-berlin.de","in-berlin.de","in-brb.de","in-butter.de","in-dsl.de","in-dsl.net","in-dsl.org","in-vpn.de","in-vpn.net","in-vpn.org","biz.at","info.at","info.cx","ac.leg.br","al.leg.br","am.leg.br","ap.leg.br","ba.leg.br","ce.leg.br","df.leg.br","es.leg.br","go.leg.br","ma.leg.br","mg.leg.br","ms.leg.br","mt.leg.br","pa.leg.br","pb.leg.br","pe.leg.br","pi.leg.br","pr.leg.br","rj.leg.br","rn.leg.br","ro.leg.br","rr.leg.br","rs.leg.br","sc.leg.br","se.leg.br","sp.leg.br","to.leg.br","pixolino.com","ipifony.net","mein-iserv.de","test-iserv.de","iserv.dev","iobb.net","myjino.ru","*.hosting.myjino.ru","*.landing.myjino.ru","*.spectrum.myjino.ru","*.vps.myjino.ru","*.triton.zone","*.cns.joyent.com","js.org","kaas.gg","khplay.nl","keymachine.de","kinghost.net","uni5.net","knightpoint.systems","oya.to","co.krd","edu.krd","git-repos.de","lcube-server.de","svn-repos.de","leadpages.co","lpages.co","lpusercontent.com","lelux.site","co.business","co.education","co.events","co.financial","co.network","co.place","co.technology","app.lmpm.com","linkitools.space","linkyard.cloud","linkyard-cloud.ch","members.linode.com","nodebalancer.linode.com","we.bs","loginline.app","loginline.dev","loginline.io","loginline.services","loginline.site","krasnik.pl","leczna.pl","lubartow.pl","lublin.pl","poniatowa.pl","swidnik.pl","uklugs.org","glug.org.uk","lug.org.uk","lugs.org.uk","barsy.bg","barsy.co.uk","barsyonline.co.uk","barsycenter.com","barsyonline.com","barsy.club","barsy.de","barsy.eu","barsy.in","barsy.info","barsy.io","barsy.me","barsy.menu","barsy.mobi","barsy.net","barsy.online","barsy.org","barsy.pro","barsy.pub","barsy.shop","barsy.site","barsy.support","barsy.uk","*.magentosite.cloud","mayfirst.info","mayfirst.org","hb.cldmail.ru","miniserver.com","memset.net","cloud.metacentrum.cz","custom.metacentrum.cz","flt.cloud.muni.cz","usr.cloud.muni.cz","meteorapp.com","eu.meteorapp.com","co.pl","azurecontainer.io","azurewebsites.net","azure-mobile.net","cloudapp.net","mozilla-iot.org","bmoattachments.org","net.ru","org.ru","pp.ru","ui.nabu.casa","pony.club","of.fashion","on.fashion","of.football","in.london","of.london","for.men","and.mom","for.mom","for.one","for.sale","of.work","to.work","nctu.me","bitballoon.com","netlify.com","4u.com","ngrok.io","nh-serv.co.uk","nfshost.com","dnsking.ch","mypi.co","n4t.co","001www.com","ddnslive.com","myiphost.com","forumz.info","16-b.it","32-b.it","64-b.it","soundcast.me","tcp4.me","dnsup.net","hicam.net","now-dns.net","ownip.net","vpndns.net","dynserv.org","now-dns.org","x443.pw","now-dns.top","ntdll.top","freeddns.us","crafting.xyz","zapto.xyz","nsupdate.info","nerdpol.ovh","blogsyte.com","brasilia.me","cable-modem.org","ciscofreak.com","collegefan.org","couchpotatofries.org","damnserver.com","ddns.me","ditchyourip.com","dnsfor.me","dnsiskinky.com","dvrcam.info","dynns.com","eating-organic.net","fantasyleague.cc","geekgalaxy.com","golffan.us","health-carereform.com","homesecuritymac.com","homesecuritypc.com","hopto.me","ilovecollege.info","loginto.me","mlbfan.org","mmafan.biz","myactivedirectory.com","mydissent.net","myeffect.net","mymediapc.net","mypsx.net","mysecuritycamera.com","mysecuritycamera.net","mysecuritycamera.org","net-freaks.com","nflfan.org","nhlfan.net","no-ip.ca","no-ip.co.uk","no-ip.net","noip.us","onthewifi.com","pgafan.net","point2this.com","pointto.us","privatizehealthinsurance.net","quicksytes.com","read-books.org","securitytactics.com","serveexchange.com","servehumour.com","servep2p.com","servesarcasm.com","stufftoread.com","ufcfan.org","unusualperson.com","workisboring.com","3utilities.com","bounceme.net","ddns.net","ddnsking.com","gotdns.ch","hopto.org","myftp.biz","myftp.org","myvnc.com","no-ip.biz","no-ip.info","no-ip.org","noip.me","redirectme.net","servebeer.com","serveblog.net","servecounterstrike.com","serveftp.com","servegame.com","servehalflife.com","servehttp.com","serveirc.com","serveminecraft.net","servemp3.com","servepics.com","servequake.com","sytes.net","webhop.me","zapto.org","stage.nodeart.io","nodum.co","nodum.io","pcloud.host","nyc.mn","nom.ae","nom.af","nom.ai","nom.al","nym.by","nom.bz","nym.bz","nom.cl","nym.ec","nom.gd","nom.ge","nom.gl","nym.gr","nom.gt","nym.gy","nym.hk","nom.hn","nym.ie","nom.im","nom.ke","nym.kz","nym.la","nym.lc","nom.li","nym.li","nym.lt","nym.lu","nom.lv","nym.me","nom.mk","nym.mn","nym.mx","nom.nu","nym.nz","nym.pe","nym.pt","nom.pw","nom.qa","nym.ro","nom.rs","nom.si","nym.sk","nom.st","nym.su","nym.sx","nom.tj","nym.tw","nom.ug","nom.uy","nom.vc","nom.vg","static.observableusercontent.com","cya.gg","cloudycluster.net","nid.io","opencraft.hosting","operaunite.com","skygearapp.com","outsystemscloud.com","ownprovider.com","own.pm","ox.rs","oy.lc","pgfog.com","pagefrontapp.com","art.pl","gliwice.pl","krakow.pl","poznan.pl","wroc.pl","zakopane.pl","pantheonsite.io","gotpantheon.com","mypep.link","perspecta.cloud","on-web.fr","*.platform.sh","*.platformsh.site","dyn53.io","co.bn","xen.prgmr.com","priv.at","prvcy.page","*.dweb.link","protonet.io","chirurgiens-dentistes-en-france.fr","byen.site","pubtls.org","qualifioapp.com","qbuser.com","instantcloud.cn","ras.ru","qa2.com","qcx.io","*.sys.qcx.io","dev-myqnapcloud.com","alpha-myqnapcloud.com","myqnapcloud.com","*.quipelements.com","vapor.cloud","vaporcloud.io","rackmaze.com","rackmaze.net","*.on-k3s.io","*.on-rancher.cloud","*.on-rio.io","readthedocs.io","rhcloud.com","app.render.com","onrender.com","repl.co","repl.run","resindevice.io","devices.resinstaging.io","hzc.io","wellbeingzone.eu","ptplus.fit","wellbeingzone.co.uk","git-pages.rit.edu","sandcats.io","logoip.de","logoip.com","schokokeks.net","gov.scot","scrysec.com","firewall-gateway.com","firewall-gateway.de","my-gateway.de","my-router.de","spdns.de","spdns.eu","firewall-gateway.net","my-firewall.org","myfirewall.org","spdns.org","senseering.net","biz.ua","co.ua","pp.ua","shiftedit.io","myshopblocks.com","shopitsite.com","mo-siemens.io","1kapp.com","appchizi.com","applinzi.com","sinaapp.com","vipsinaapp.com","siteleaf.net","bounty-full.com","alpha.bounty-full.com","beta.bounty-full.com","stackhero-network.com","static.land","dev.static.land","sites.static.land","apps.lair.io","*.stolos.io","spacekit.io","customer.speedpartner.de","api.stdlib.com","storj.farm","utwente.io","soc.srcf.net","user.srcf.net","temp-dns.com","applicationcloud.io","scapp.io","*.s5y.io","*.sensiosite.cloud","syncloud.it","diskstation.me","dscloud.biz","dscloud.me","dscloud.mobi","dsmynas.com","dsmynas.net","dsmynas.org","familyds.com","familyds.net","familyds.org","i234.me","myds.me","synology.me","vpnplus.to","direct.quickconnect.to","taifun-dns.de","gda.pl","gdansk.pl","gdynia.pl","med.pl","sopot.pl","edugit.org","telebit.app","telebit.io","*.telebit.xyz","gwiddle.co.uk","thingdustdata.com","cust.dev.thingdust.io","cust.disrec.thingdust.io","cust.prod.thingdust.io","cust.testing.thingdust.io","arvo.network","azimuth.network","bloxcms.com","townnews-staging.com","12hp.at","2ix.at","4lima.at","lima-city.at","12hp.ch","2ix.ch","4lima.ch","lima-city.ch","trafficplex.cloud","de.cool","12hp.de","2ix.de","4lima.de","lima-city.de","1337.pictures","clan.rip","lima-city.rocks","webspace.rocks","lima.zone","*.transurl.be","*.transurl.eu","*.transurl.nl","tuxfamily.org","dd-dns.de","diskstation.eu","diskstation.org","dray-dns.de","draydns.de","dyn-vpn.de","dynvpn.de","mein-vigor.de","my-vigor.de","my-wan.de","syno-ds.de","synology-diskstation.de","synology-ds.de","uber.space","*.uberspace.de","hk.com","hk.org","ltd.hk","inc.hk","virtualuser.de","virtual-user.de","urown.cloud","dnsupdate.info","lib.de.us","2038.io","router.management","v-info.info","voorloper.cloud","v.ua","wafflecell.com","*.webhare.dev","wedeploy.io","wedeploy.me","wedeploy.sh","remotewd.com","wmflabs.org","myforum.community","community-pro.de","diskussionsbereich.de","community-pro.net","meinforum.net","half.host","xnbay.com","u2.xnbay.com","u2-local.xnbay.com","cistron.nl","demon.nl","xs4all.space","yandexcloud.net","storage.yandexcloud.net","website.yandexcloud.net","official.academy","yolasite.com","ybo.faith","yombo.me","homelink.one","ybo.party","ybo.review","ybo.science","ybo.trade","nohost.me","noho.st","za.net","za.org","now.sh","bss.design","basicserver.io","virtualserver.io","enterprisecloud.nu"];
|
||
|
||
/***/ }),
|
||
/* 51 */,
|
||
/* 52 */,
|
||
/* 53 */,
|
||
/* 54 */,
|
||
/* 55 */,
|
||
/* 56 */,
|
||
/* 57 */,
|
||
/* 58 */,
|
||
/* 59 */,
|
||
/* 60 */,
|
||
/* 61 */,
|
||
/* 62 */,
|
||
/* 63 */,
|
||
/* 64 */,
|
||
/* 65 */
|
||
/***/ (function(module) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
module.exports = {
|
||
Disconnected: 1,
|
||
Preceding: 2,
|
||
Following: 4,
|
||
Contains: 8,
|
||
ContainedBy: 16,
|
||
ImplementationSpecific: 32
|
||
};
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 66 */,
|
||
/* 67 */,
|
||
/* 68 */,
|
||
/* 69 */,
|
||
/* 70 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
exports.URL = __webpack_require__(782).interface;
|
||
exports.serializeURL = __webpack_require__(936).serializeURL;
|
||
exports.serializeURLOrigin = __webpack_require__(936).serializeURLOrigin;
|
||
exports.basicURLParse = __webpack_require__(936).basicURLParse;
|
||
exports.setTheUsername = __webpack_require__(936).setTheUsername;
|
||
exports.setThePassword = __webpack_require__(936).setThePassword;
|
||
exports.serializeHost = __webpack_require__(936).serializeHost;
|
||
exports.serializeInteger = __webpack_require__(936).serializeInteger;
|
||
exports.parseURL = __webpack_require__(936).parseURL;
|
||
|
||
|
||
/***/ }),
|
||
/* 71 */,
|
||
/* 72 */,
|
||
/* 73 */,
|
||
/* 74 */,
|
||
/* 75 */,
|
||
/* 76 */,
|
||
/* 77 */,
|
||
/* 78 */,
|
||
/* 79 */,
|
||
/* 80 */,
|
||
/* 81 */,
|
||
/* 82 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
// We use any as a valid input type
|
||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.toCommandProperties = exports.toCommandValue = void 0;
|
||
/**
|
||
* Sanitizes an input into a string so it can be passed into issueCommand safely
|
||
* @param input input to sanitize into a string
|
||
*/
|
||
function toCommandValue(input) {
|
||
if (input === null || input === undefined) {
|
||
return '';
|
||
}
|
||
else if (typeof input === 'string' || input instanceof String) {
|
||
return input;
|
||
}
|
||
return JSON.stringify(input);
|
||
}
|
||
exports.toCommandValue = toCommandValue;
|
||
/**
|
||
*
|
||
* @param annotationProperties
|
||
* @returns The command properties to send with the actual annotation command
|
||
* See IssueCommandProperties: https://github.com/actions/runner/blob/main/src/Runner.Worker/ActionCommandManager.cs#L646
|
||
*/
|
||
function toCommandProperties(annotationProperties) {
|
||
if (!Object.keys(annotationProperties).length) {
|
||
return {};
|
||
}
|
||
return {
|
||
title: annotationProperties.title,
|
||
file: annotationProperties.file,
|
||
line: annotationProperties.startLine,
|
||
endLine: annotationProperties.endLine,
|
||
col: annotationProperties.startColumn,
|
||
endColumn: annotationProperties.endColumn
|
||
};
|
||
}
|
||
exports.toCommandProperties = toCommandProperties;
|
||
//# sourceMappingURL=utils.js.map
|
||
|
||
/***/ }),
|
||
/* 83 */,
|
||
/* 84 */,
|
||
/* 85 */,
|
||
/* 86 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var rng = __webpack_require__(139);
|
||
var bytesToUuid = __webpack_require__(722);
|
||
|
||
// **`v1()` - Generate time-based UUID**
|
||
//
|
||
// Inspired by https://github.com/LiosK/UUID.js
|
||
// and http://docs.python.org/library/uuid.html
|
||
|
||
var _nodeId;
|
||
var _clockseq;
|
||
|
||
// Previous uuid creation time
|
||
var _lastMSecs = 0;
|
||
var _lastNSecs = 0;
|
||
|
||
// See https://github.com/uuidjs/uuid for API details
|
||
function v1(options, buf, offset) {
|
||
var i = buf && offset || 0;
|
||
var b = buf || [];
|
||
|
||
options = options || {};
|
||
var node = options.node || _nodeId;
|
||
var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
|
||
|
||
// node and clockseq need to be initialized to random values if they're not
|
||
// specified. We do this lazily to minimize issues related to insufficient
|
||
// system entropy. See #189
|
||
if (node == null || clockseq == null) {
|
||
var seedBytes = rng();
|
||
if (node == null) {
|
||
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
|
||
node = _nodeId = [
|
||
seedBytes[0] | 0x01,
|
||
seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]
|
||
];
|
||
}
|
||
if (clockseq == null) {
|
||
// Per 4.2.2, randomize (14 bit) clockseq
|
||
clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
|
||
}
|
||
}
|
||
|
||
// UUID timestamps are 100 nano-second units since the Gregorian epoch,
|
||
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
|
||
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
|
||
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
|
||
var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
|
||
|
||
// Per 4.2.1.2, use count of uuid's generated during the current clock
|
||
// cycle to simulate higher resolution clock
|
||
var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
|
||
|
||
// Time since last uuid creation (in msecs)
|
||
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
|
||
|
||
// Per 4.2.1.2, Bump clockseq on clock regression
|
||
if (dt < 0 && options.clockseq === undefined) {
|
||
clockseq = clockseq + 1 & 0x3fff;
|
||
}
|
||
|
||
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
|
||
// time interval
|
||
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
|
||
nsecs = 0;
|
||
}
|
||
|
||
// Per 4.2.1.2 Throw error if too many uuids are requested
|
||
if (nsecs >= 10000) {
|
||
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
|
||
}
|
||
|
||
_lastMSecs = msecs;
|
||
_lastNSecs = nsecs;
|
||
_clockseq = clockseq;
|
||
|
||
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch
|
||
msecs += 12219292800000;
|
||
|
||
// `time_low`
|
||
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
|
||
b[i++] = tl >>> 24 & 0xff;
|
||
b[i++] = tl >>> 16 & 0xff;
|
||
b[i++] = tl >>> 8 & 0xff;
|
||
b[i++] = tl & 0xff;
|
||
|
||
// `time_mid`
|
||
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
|
||
b[i++] = tmh >>> 8 & 0xff;
|
||
b[i++] = tmh & 0xff;
|
||
|
||
// `time_high_and_version`
|
||
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
|
||
b[i++] = tmh >>> 16 & 0xff;
|
||
|
||
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
|
||
b[i++] = clockseq >>> 8 | 0x80;
|
||
|
||
// `clock_seq_low`
|
||
b[i++] = clockseq & 0xff;
|
||
|
||
// `node`
|
||
for (var n = 0; n < 6; ++n) {
|
||
b[i + n] = node[n];
|
||
}
|
||
|
||
return buf ? buf : bytesToUuid(b);
|
||
}
|
||
|
||
module.exports = v1;
|
||
|
||
|
||
/***/ }),
|
||
/* 87 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("os");
|
||
|
||
/***/ }),
|
||
/* 88 */,
|
||
/* 89 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/*!
|
||
* Copyright (c) 2015, Salesforce.com, Inc.
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
*
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
*
|
||
* 3. Neither the name of Salesforce.com nor the names of its contributors may
|
||
* be used to endorse or promote products derived from this software without
|
||
* specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
const pubsuffix = __webpack_require__(562);
|
||
|
||
// Gives the permutation of all possible domainMatch()es of a given domain. The
|
||
// array is in shortest-to-longest order. Handy for indexing.
|
||
const SPECIAL_USE_DOMAINS = ["local"]; // RFC 6761
|
||
function permuteDomain(domain, allowSpecialUseDomain) {
|
||
let pubSuf = null;
|
||
if (allowSpecialUseDomain) {
|
||
const domainParts = domain.split(".");
|
||
if (SPECIAL_USE_DOMAINS.includes(domainParts[domainParts.length - 1])) {
|
||
pubSuf = `${domainParts[domainParts.length - 2]}.${
|
||
domainParts[domainParts.length - 1]
|
||
}`;
|
||
} else {
|
||
pubSuf = pubsuffix.getPublicSuffix(domain);
|
||
}
|
||
} else {
|
||
pubSuf = pubsuffix.getPublicSuffix(domain);
|
||
}
|
||
|
||
if (!pubSuf) {
|
||
return null;
|
||
}
|
||
if (pubSuf == domain) {
|
||
return [domain];
|
||
}
|
||
|
||
const prefix = domain.slice(0, -(pubSuf.length + 1)); // ".example.com"
|
||
const parts = prefix.split(".").reverse();
|
||
let cur = pubSuf;
|
||
const permutations = [cur];
|
||
while (parts.length) {
|
||
cur = `${parts.shift()}.${cur}`;
|
||
permutations.push(cur);
|
||
}
|
||
return permutations;
|
||
}
|
||
|
||
exports.permuteDomain = permuteDomain;
|
||
|
||
|
||
/***/ }),
|
||
/* 90 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _v = _interopRequireDefault(__webpack_require__(241));
|
||
|
||
var _sha = _interopRequireDefault(__webpack_require__(616));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
const v5 = (0, _v.default)('v5', 0x50, _sha.default);
|
||
var _default = v5;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 91 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var serialOrdered = __webpack_require__(892);
|
||
|
||
// Public API
|
||
module.exports = serial;
|
||
|
||
/**
|
||
* Runs iterator over provided array elements in series
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {function} callback - invoked when all elements processed
|
||
* @returns {function} - jobs terminator
|
||
*/
|
||
function serial(list, iterator, callback)
|
||
{
|
||
return serialOrdered(list, iterator, null, callback);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 92 */,
|
||
/* 93 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
module.exports = minimatch
|
||
minimatch.Minimatch = Minimatch
|
||
|
||
var path = (function () { try { return __webpack_require__(622) } catch (e) {}}()) || {
|
||
sep: '/'
|
||
}
|
||
minimatch.sep = path.sep
|
||
|
||
var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
|
||
var expand = __webpack_require__(306)
|
||
|
||
var plTypes = {
|
||
'!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
|
||
'?': { open: '(?:', close: ')?' },
|
||
'+': { open: '(?:', close: ')+' },
|
||
'*': { open: '(?:', close: ')*' },
|
||
'@': { open: '(?:', close: ')' }
|
||
}
|
||
|
||
// any single thing other than /
|
||
// don't need to escape / when using new RegExp()
|
||
var qmark = '[^/]'
|
||
|
||
// * => any number of characters
|
||
var star = qmark + '*?'
|
||
|
||
// ** when dots are allowed. Anything goes, except .. and .
|
||
// not (^ or / followed by one or two dots followed by $ or /),
|
||
// followed by anything, any number of times.
|
||
var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
|
||
|
||
// not a ^ or / followed by a dot,
|
||
// followed by anything, any number of times.
|
||
var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
|
||
|
||
// characters that need to be escaped in RegExp.
|
||
var reSpecials = charSet('().*{}+?[]^$\\!')
|
||
|
||
// "abc" -> { a:true, b:true, c:true }
|
||
function charSet (s) {
|
||
return s.split('').reduce(function (set, c) {
|
||
set[c] = true
|
||
return set
|
||
}, {})
|
||
}
|
||
|
||
// normalizes slashes.
|
||
var slashSplit = /\/+/
|
||
|
||
minimatch.filter = filter
|
||
function filter (pattern, options) {
|
||
options = options || {}
|
||
return function (p, i, list) {
|
||
return minimatch(p, pattern, options)
|
||
}
|
||
}
|
||
|
||
function ext (a, b) {
|
||
b = b || {}
|
||
var t = {}
|
||
Object.keys(a).forEach(function (k) {
|
||
t[k] = a[k]
|
||
})
|
||
Object.keys(b).forEach(function (k) {
|
||
t[k] = b[k]
|
||
})
|
||
return t
|
||
}
|
||
|
||
minimatch.defaults = function (def) {
|
||
if (!def || typeof def !== 'object' || !Object.keys(def).length) {
|
||
return minimatch
|
||
}
|
||
|
||
var orig = minimatch
|
||
|
||
var m = function minimatch (p, pattern, options) {
|
||
return orig(p, pattern, ext(def, options))
|
||
}
|
||
|
||
m.Minimatch = function Minimatch (pattern, options) {
|
||
return new orig.Minimatch(pattern, ext(def, options))
|
||
}
|
||
m.Minimatch.defaults = function defaults (options) {
|
||
return orig.defaults(ext(def, options)).Minimatch
|
||
}
|
||
|
||
m.filter = function filter (pattern, options) {
|
||
return orig.filter(pattern, ext(def, options))
|
||
}
|
||
|
||
m.defaults = function defaults (options) {
|
||
return orig.defaults(ext(def, options))
|
||
}
|
||
|
||
m.makeRe = function makeRe (pattern, options) {
|
||
return orig.makeRe(pattern, ext(def, options))
|
||
}
|
||
|
||
m.braceExpand = function braceExpand (pattern, options) {
|
||
return orig.braceExpand(pattern, ext(def, options))
|
||
}
|
||
|
||
m.match = function (list, pattern, options) {
|
||
return orig.match(list, pattern, ext(def, options))
|
||
}
|
||
|
||
return m
|
||
}
|
||
|
||
Minimatch.defaults = function (def) {
|
||
return minimatch.defaults(def).Minimatch
|
||
}
|
||
|
||
function minimatch (p, pattern, options) {
|
||
assertValidPattern(pattern)
|
||
|
||
if (!options) options = {}
|
||
|
||
// shortcut: comments match nothing.
|
||
if (!options.nocomment && pattern.charAt(0) === '#') {
|
||
return false
|
||
}
|
||
|
||
return new Minimatch(pattern, options).match(p)
|
||
}
|
||
|
||
function Minimatch (pattern, options) {
|
||
if (!(this instanceof Minimatch)) {
|
||
return new Minimatch(pattern, options)
|
||
}
|
||
|
||
assertValidPattern(pattern)
|
||
|
||
if (!options) options = {}
|
||
|
||
pattern = pattern.trim()
|
||
|
||
// windows support: need to use /, not \
|
||
if (!options.allowWindowsEscape && path.sep !== '/') {
|
||
pattern = pattern.split(path.sep).join('/')
|
||
}
|
||
|
||
this.options = options
|
||
this.set = []
|
||
this.pattern = pattern
|
||
this.regexp = null
|
||
this.negate = false
|
||
this.comment = false
|
||
this.empty = false
|
||
this.partial = !!options.partial
|
||
|
||
// make the set of regexps etc.
|
||
this.make()
|
||
}
|
||
|
||
Minimatch.prototype.debug = function () {}
|
||
|
||
Minimatch.prototype.make = make
|
||
function make () {
|
||
var pattern = this.pattern
|
||
var options = this.options
|
||
|
||
// empty patterns and comments match nothing.
|
||
if (!options.nocomment && pattern.charAt(0) === '#') {
|
||
this.comment = true
|
||
return
|
||
}
|
||
if (!pattern) {
|
||
this.empty = true
|
||
return
|
||
}
|
||
|
||
// step 1: figure out negation, etc.
|
||
this.parseNegate()
|
||
|
||
// step 2: expand braces
|
||
var set = this.globSet = this.braceExpand()
|
||
|
||
if (options.debug) this.debug = function debug() { console.error.apply(console, arguments) }
|
||
|
||
this.debug(this.pattern, set)
|
||
|
||
// step 3: now we have a set, so turn each one into a series of path-portion
|
||
// matching patterns.
|
||
// These will be regexps, except in the case of "**", which is
|
||
// set to the GLOBSTAR object for globstar behavior,
|
||
// and will not contain any / characters
|
||
set = this.globParts = set.map(function (s) {
|
||
return s.split(slashSplit)
|
||
})
|
||
|
||
this.debug(this.pattern, set)
|
||
|
||
// glob --> regexps
|
||
set = set.map(function (s, si, set) {
|
||
return s.map(this.parse, this)
|
||
}, this)
|
||
|
||
this.debug(this.pattern, set)
|
||
|
||
// filter out everything that didn't compile properly.
|
||
set = set.filter(function (s) {
|
||
return s.indexOf(false) === -1
|
||
})
|
||
|
||
this.debug(this.pattern, set)
|
||
|
||
this.set = set
|
||
}
|
||
|
||
Minimatch.prototype.parseNegate = parseNegate
|
||
function parseNegate () {
|
||
var pattern = this.pattern
|
||
var negate = false
|
||
var options = this.options
|
||
var negateOffset = 0
|
||
|
||
if (options.nonegate) return
|
||
|
||
for (var i = 0, l = pattern.length
|
||
; i < l && pattern.charAt(i) === '!'
|
||
; i++) {
|
||
negate = !negate
|
||
negateOffset++
|
||
}
|
||
|
||
if (negateOffset) this.pattern = pattern.substr(negateOffset)
|
||
this.negate = negate
|
||
}
|
||
|
||
// Brace expansion:
|
||
// a{b,c}d -> abd acd
|
||
// a{b,}c -> abc ac
|
||
// a{0..3}d -> a0d a1d a2d a3d
|
||
// a{b,c{d,e}f}g -> abg acdfg acefg
|
||
// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
|
||
//
|
||
// Invalid sets are not expanded.
|
||
// a{2..}b -> a{2..}b
|
||
// a{b}c -> a{b}c
|
||
minimatch.braceExpand = function (pattern, options) {
|
||
return braceExpand(pattern, options)
|
||
}
|
||
|
||
Minimatch.prototype.braceExpand = braceExpand
|
||
|
||
function braceExpand (pattern, options) {
|
||
if (!options) {
|
||
if (this instanceof Minimatch) {
|
||
options = this.options
|
||
} else {
|
||
options = {}
|
||
}
|
||
}
|
||
|
||
pattern = typeof pattern === 'undefined'
|
||
? this.pattern : pattern
|
||
|
||
assertValidPattern(pattern)
|
||
|
||
// Thanks to Yeting Li <https://github.com/yetingli> for
|
||
// improving this regexp to avoid a ReDOS vulnerability.
|
||
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
|
||
// shortcut. no need to expand.
|
||
return [pattern]
|
||
}
|
||
|
||
return expand(pattern)
|
||
}
|
||
|
||
var MAX_PATTERN_LENGTH = 1024 * 64
|
||
var assertValidPattern = function (pattern) {
|
||
if (typeof pattern !== 'string') {
|
||
throw new TypeError('invalid pattern')
|
||
}
|
||
|
||
if (pattern.length > MAX_PATTERN_LENGTH) {
|
||
throw new TypeError('pattern is too long')
|
||
}
|
||
}
|
||
|
||
// parse a component of the expanded set.
|
||
// At this point, no pattern may contain "/" in it
|
||
// so we're going to return a 2d array, where each entry is the full
|
||
// pattern, split on '/', and then turned into a regular expression.
|
||
// A regexp is made at the end which joins each array with an
|
||
// escaped /, and another full one which joins each regexp with |.
|
||
//
|
||
// Following the lead of Bash 4.1, note that "**" only has special meaning
|
||
// when it is the *only* thing in a path portion. Otherwise, any series
|
||
// of * is equivalent to a single *. Globstar behavior is enabled by
|
||
// default, and can be disabled by setting options.noglobstar.
|
||
Minimatch.prototype.parse = parse
|
||
var SUBPARSE = {}
|
||
function parse (pattern, isSub) {
|
||
assertValidPattern(pattern)
|
||
|
||
var options = this.options
|
||
|
||
// shortcuts
|
||
if (pattern === '**') {
|
||
if (!options.noglobstar)
|
||
return GLOBSTAR
|
||
else
|
||
pattern = '*'
|
||
}
|
||
if (pattern === '') return ''
|
||
|
||
var re = ''
|
||
var hasMagic = !!options.nocase
|
||
var escaping = false
|
||
// ? => one single character
|
||
var patternListStack = []
|
||
var negativeLists = []
|
||
var stateChar
|
||
var inClass = false
|
||
var reClassStart = -1
|
||
var classStart = -1
|
||
// . and .. never match anything that doesn't start with .,
|
||
// even when options.dot is set.
|
||
var patternStart = pattern.charAt(0) === '.' ? '' // anything
|
||
// not (start or / followed by . or .. followed by / or end)
|
||
: options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
|
||
: '(?!\\.)'
|
||
var self = this
|
||
|
||
function clearStateChar () {
|
||
if (stateChar) {
|
||
// we had some state-tracking character
|
||
// that wasn't consumed by this pass.
|
||
switch (stateChar) {
|
||
case '*':
|
||
re += star
|
||
hasMagic = true
|
||
break
|
||
case '?':
|
||
re += qmark
|
||
hasMagic = true
|
||
break
|
||
default:
|
||
re += '\\' + stateChar
|
||
break
|
||
}
|
||
self.debug('clearStateChar %j %j', stateChar, re)
|
||
stateChar = false
|
||
}
|
||
}
|
||
|
||
for (var i = 0, len = pattern.length, c
|
||
; (i < len) && (c = pattern.charAt(i))
|
||
; i++) {
|
||
this.debug('%s\t%s %s %j', pattern, i, re, c)
|
||
|
||
// skip over any that are escaped.
|
||
if (escaping && reSpecials[c]) {
|
||
re += '\\' + c
|
||
escaping = false
|
||
continue
|
||
}
|
||
|
||
switch (c) {
|
||
/* istanbul ignore next */
|
||
case '/': {
|
||
// completely not allowed, even escaped.
|
||
// Should already be path-split by now.
|
||
return false
|
||
}
|
||
|
||
case '\\':
|
||
clearStateChar()
|
||
escaping = true
|
||
continue
|
||
|
||
// the various stateChar values
|
||
// for the "extglob" stuff.
|
||
case '?':
|
||
case '*':
|
||
case '+':
|
||
case '@':
|
||
case '!':
|
||
this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
|
||
|
||
// all of those are literals inside a class, except that
|
||
// the glob [!a] means [^a] in regexp
|
||
if (inClass) {
|
||
this.debug(' in class')
|
||
if (c === '!' && i === classStart + 1) c = '^'
|
||
re += c
|
||
continue
|
||
}
|
||
|
||
// if we already have a stateChar, then it means
|
||
// that there was something like ** or +? in there.
|
||
// Handle the stateChar, then proceed with this one.
|
||
self.debug('call clearStateChar %j', stateChar)
|
||
clearStateChar()
|
||
stateChar = c
|
||
// if extglob is disabled, then +(asdf|foo) isn't a thing.
|
||
// just clear the statechar *now*, rather than even diving into
|
||
// the patternList stuff.
|
||
if (options.noext) clearStateChar()
|
||
continue
|
||
|
||
case '(':
|
||
if (inClass) {
|
||
re += '('
|
||
continue
|
||
}
|
||
|
||
if (!stateChar) {
|
||
re += '\\('
|
||
continue
|
||
}
|
||
|
||
patternListStack.push({
|
||
type: stateChar,
|
||
start: i - 1,
|
||
reStart: re.length,
|
||
open: plTypes[stateChar].open,
|
||
close: plTypes[stateChar].close
|
||
})
|
||
// negation is (?:(?!js)[^/]*)
|
||
re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
|
||
this.debug('plType %j %j', stateChar, re)
|
||
stateChar = false
|
||
continue
|
||
|
||
case ')':
|
||
if (inClass || !patternListStack.length) {
|
||
re += '\\)'
|
||
continue
|
||
}
|
||
|
||
clearStateChar()
|
||
hasMagic = true
|
||
var pl = patternListStack.pop()
|
||
// negation is (?:(?!js)[^/]*)
|
||
// The others are (?:<pattern>)<type>
|
||
re += pl.close
|
||
if (pl.type === '!') {
|
||
negativeLists.push(pl)
|
||
}
|
||
pl.reEnd = re.length
|
||
continue
|
||
|
||
case '|':
|
||
if (inClass || !patternListStack.length || escaping) {
|
||
re += '\\|'
|
||
escaping = false
|
||
continue
|
||
}
|
||
|
||
clearStateChar()
|
||
re += '|'
|
||
continue
|
||
|
||
// these are mostly the same in regexp and glob
|
||
case '[':
|
||
// swallow any state-tracking char before the [
|
||
clearStateChar()
|
||
|
||
if (inClass) {
|
||
re += '\\' + c
|
||
continue
|
||
}
|
||
|
||
inClass = true
|
||
classStart = i
|
||
reClassStart = re.length
|
||
re += c
|
||
continue
|
||
|
||
case ']':
|
||
// a right bracket shall lose its special
|
||
// meaning and represent itself in
|
||
// a bracket expression if it occurs
|
||
// first in the list. -- POSIX.2 2.8.3.2
|
||
if (i === classStart + 1 || !inClass) {
|
||
re += '\\' + c
|
||
escaping = false
|
||
continue
|
||
}
|
||
|
||
// handle the case where we left a class open.
|
||
// "[z-a]" is valid, equivalent to "\[z-a\]"
|
||
// split where the last [ was, make sure we don't have
|
||
// an invalid re. if so, re-walk the contents of the
|
||
// would-be class to re-translate any characters that
|
||
// were passed through as-is
|
||
// TODO: It would probably be faster to determine this
|
||
// without a try/catch and a new RegExp, but it's tricky
|
||
// to do safely. For now, this is safe and works.
|
||
var cs = pattern.substring(classStart + 1, i)
|
||
try {
|
||
RegExp('[' + cs + ']')
|
||
} catch (er) {
|
||
// not a valid class!
|
||
var sp = this.parse(cs, SUBPARSE)
|
||
re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
|
||
hasMagic = hasMagic || sp[1]
|
||
inClass = false
|
||
continue
|
||
}
|
||
|
||
// finish up the class.
|
||
hasMagic = true
|
||
inClass = false
|
||
re += c
|
||
continue
|
||
|
||
default:
|
||
// swallow any state char that wasn't consumed
|
||
clearStateChar()
|
||
|
||
if (escaping) {
|
||
// no need
|
||
escaping = false
|
||
} else if (reSpecials[c]
|
||
&& !(c === '^' && inClass)) {
|
||
re += '\\'
|
||
}
|
||
|
||
re += c
|
||
|
||
} // switch
|
||
} // for
|
||
|
||
// handle the case where we left a class open.
|
||
// "[abc" is valid, equivalent to "\[abc"
|
||
if (inClass) {
|
||
// split where the last [ was, and escape it
|
||
// this is a huge pita. We now have to re-walk
|
||
// the contents of the would-be class to re-translate
|
||
// any characters that were passed through as-is
|
||
cs = pattern.substr(classStart + 1)
|
||
sp = this.parse(cs, SUBPARSE)
|
||
re = re.substr(0, reClassStart) + '\\[' + sp[0]
|
||
hasMagic = hasMagic || sp[1]
|
||
}
|
||
|
||
// handle the case where we had a +( thing at the *end*
|
||
// of the pattern.
|
||
// each pattern list stack adds 3 chars, and we need to go through
|
||
// and escape any | chars that were passed through as-is for the regexp.
|
||
// Go through and escape them, taking care not to double-escape any
|
||
// | chars that were already escaped.
|
||
for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
|
||
var tail = re.slice(pl.reStart + pl.open.length)
|
||
this.debug('setting tail', re, pl)
|
||
// maybe some even number of \, then maybe 1 \, followed by a |
|
||
tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
|
||
if (!$2) {
|
||
// the | isn't already escaped, so escape it.
|
||
$2 = '\\'
|
||
}
|
||
|
||
// need to escape all those slashes *again*, without escaping the
|
||
// one that we need for escaping the | character. As it works out,
|
||
// escaping an even number of slashes can be done by simply repeating
|
||
// it exactly after itself. That's why this trick works.
|
||
//
|
||
// I am sorry that you have to see this.
|
||
return $1 + $1 + $2 + '|'
|
||
})
|
||
|
||
this.debug('tail=%j\n %s', tail, tail, pl, re)
|
||
var t = pl.type === '*' ? star
|
||
: pl.type === '?' ? qmark
|
||
: '\\' + pl.type
|
||
|
||
hasMagic = true
|
||
re = re.slice(0, pl.reStart) + t + '\\(' + tail
|
||
}
|
||
|
||
// handle trailing things that only matter at the very end.
|
||
clearStateChar()
|
||
if (escaping) {
|
||
// trailing \\
|
||
re += '\\\\'
|
||
}
|
||
|
||
// only need to apply the nodot start if the re starts with
|
||
// something that could conceivably capture a dot
|
||
var addPatternStart = false
|
||
switch (re.charAt(0)) {
|
||
case '[': case '.': case '(': addPatternStart = true
|
||
}
|
||
|
||
// Hack to work around lack of negative lookbehind in JS
|
||
// A pattern like: *.!(x).!(y|z) needs to ensure that a name
|
||
// like 'a.xyz.yz' doesn't match. So, the first negative
|
||
// lookahead, has to look ALL the way ahead, to the end of
|
||
// the pattern.
|
||
for (var n = negativeLists.length - 1; n > -1; n--) {
|
||
var nl = negativeLists[n]
|
||
|
||
var nlBefore = re.slice(0, nl.reStart)
|
||
var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
|
||
var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
|
||
var nlAfter = re.slice(nl.reEnd)
|
||
|
||
nlLast += nlAfter
|
||
|
||
// Handle nested stuff like *(*.js|!(*.json)), where open parens
|
||
// mean that we should *not* include the ) in the bit that is considered
|
||
// "after" the negated section.
|
||
var openParensBefore = nlBefore.split('(').length - 1
|
||
var cleanAfter = nlAfter
|
||
for (i = 0; i < openParensBefore; i++) {
|
||
cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
|
||
}
|
||
nlAfter = cleanAfter
|
||
|
||
var dollar = ''
|
||
if (nlAfter === '' && isSub !== SUBPARSE) {
|
||
dollar = '$'
|
||
}
|
||
var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
|
||
re = newRe
|
||
}
|
||
|
||
// if the re is not "" at this point, then we need to make sure
|
||
// it doesn't match against an empty path part.
|
||
// Otherwise a/* will match a/, which it should not.
|
||
if (re !== '' && hasMagic) {
|
||
re = '(?=.)' + re
|
||
}
|
||
|
||
if (addPatternStart) {
|
||
re = patternStart + re
|
||
}
|
||
|
||
// parsing just a piece of a larger pattern.
|
||
if (isSub === SUBPARSE) {
|
||
return [re, hasMagic]
|
||
}
|
||
|
||
// skip the regexp for non-magical patterns
|
||
// unescape anything in it, though, so that it'll be
|
||
// an exact match against a file etc.
|
||
if (!hasMagic) {
|
||
return globUnescape(pattern)
|
||
}
|
||
|
||
var flags = options.nocase ? 'i' : ''
|
||
try {
|
||
var regExp = new RegExp('^' + re + '$', flags)
|
||
} catch (er) /* istanbul ignore next - should be impossible */ {
|
||
// If it was an invalid regular expression, then it can't match
|
||
// anything. This trick looks for a character after the end of
|
||
// the string, which is of course impossible, except in multi-line
|
||
// mode, but it's not a /m regex.
|
||
return new RegExp('$.')
|
||
}
|
||
|
||
regExp._glob = pattern
|
||
regExp._src = re
|
||
|
||
return regExp
|
||
}
|
||
|
||
minimatch.makeRe = function (pattern, options) {
|
||
return new Minimatch(pattern, options || {}).makeRe()
|
||
}
|
||
|
||
Minimatch.prototype.makeRe = makeRe
|
||
function makeRe () {
|
||
if (this.regexp || this.regexp === false) return this.regexp
|
||
|
||
// at this point, this.set is a 2d array of partial
|
||
// pattern strings, or "**".
|
||
//
|
||
// It's better to use .match(). This function shouldn't
|
||
// be used, really, but it's pretty convenient sometimes,
|
||
// when you just want to work with a regex.
|
||
var set = this.set
|
||
|
||
if (!set.length) {
|
||
this.regexp = false
|
||
return this.regexp
|
||
}
|
||
var options = this.options
|
||
|
||
var twoStar = options.noglobstar ? star
|
||
: options.dot ? twoStarDot
|
||
: twoStarNoDot
|
||
var flags = options.nocase ? 'i' : ''
|
||
|
||
var re = set.map(function (pattern) {
|
||
return pattern.map(function (p) {
|
||
return (p === GLOBSTAR) ? twoStar
|
||
: (typeof p === 'string') ? regExpEscape(p)
|
||
: p._src
|
||
}).join('\\\/')
|
||
}).join('|')
|
||
|
||
// must match entire pattern
|
||
// ending in a * or ** will make it less strict.
|
||
re = '^(?:' + re + ')$'
|
||
|
||
// can match anything, as long as it's not this.
|
||
if (this.negate) re = '^(?!' + re + ').*$'
|
||
|
||
try {
|
||
this.regexp = new RegExp(re, flags)
|
||
} catch (ex) /* istanbul ignore next - should be impossible */ {
|
||
this.regexp = false
|
||
}
|
||
return this.regexp
|
||
}
|
||
|
||
minimatch.match = function (list, pattern, options) {
|
||
options = options || {}
|
||
var mm = new Minimatch(pattern, options)
|
||
list = list.filter(function (f) {
|
||
return mm.match(f)
|
||
})
|
||
if (mm.options.nonull && !list.length) {
|
||
list.push(pattern)
|
||
}
|
||
return list
|
||
}
|
||
|
||
Minimatch.prototype.match = function match (f, partial) {
|
||
if (typeof partial === 'undefined') partial = this.partial
|
||
this.debug('match', f, this.pattern)
|
||
// short-circuit in the case of busted things.
|
||
// comments, etc.
|
||
if (this.comment) return false
|
||
if (this.empty) return f === ''
|
||
|
||
if (f === '/' && partial) return true
|
||
|
||
var options = this.options
|
||
|
||
// windows: need to use /, not \
|
||
if (path.sep !== '/') {
|
||
f = f.split(path.sep).join('/')
|
||
}
|
||
|
||
// treat the test path as a set of pathparts.
|
||
f = f.split(slashSplit)
|
||
this.debug(this.pattern, 'split', f)
|
||
|
||
// just ONE of the pattern sets in this.set needs to match
|
||
// in order for it to be valid. If negating, then just one
|
||
// match means that we have failed.
|
||
// Either way, return on the first hit.
|
||
|
||
var set = this.set
|
||
this.debug(this.pattern, 'set', set)
|
||
|
||
// Find the basename of the path by looking for the last non-empty segment
|
||
var filename
|
||
var i
|
||
for (i = f.length - 1; i >= 0; i--) {
|
||
filename = f[i]
|
||
if (filename) break
|
||
}
|
||
|
||
for (i = 0; i < set.length; i++) {
|
||
var pattern = set[i]
|
||
var file = f
|
||
if (options.matchBase && pattern.length === 1) {
|
||
file = [filename]
|
||
}
|
||
var hit = this.matchOne(file, pattern, partial)
|
||
if (hit) {
|
||
if (options.flipNegate) return true
|
||
return !this.negate
|
||
}
|
||
}
|
||
|
||
// didn't get any hits. this is success if it's a negative
|
||
// pattern, failure otherwise.
|
||
if (options.flipNegate) return false
|
||
return this.negate
|
||
}
|
||
|
||
// set partial to true to test if, for example,
|
||
// "/a/b" matches the start of "/*/b/*/d"
|
||
// Partial means, if you run out of file before you run
|
||
// out of pattern, then that's fine, as long as all
|
||
// the parts match.
|
||
Minimatch.prototype.matchOne = function (file, pattern, partial) {
|
||
var options = this.options
|
||
|
||
this.debug('matchOne',
|
||
{ 'this': this, file: file, pattern: pattern })
|
||
|
||
this.debug('matchOne', file.length, pattern.length)
|
||
|
||
for (var fi = 0,
|
||
pi = 0,
|
||
fl = file.length,
|
||
pl = pattern.length
|
||
; (fi < fl) && (pi < pl)
|
||
; fi++, pi++) {
|
||
this.debug('matchOne loop')
|
||
var p = pattern[pi]
|
||
var f = file[fi]
|
||
|
||
this.debug(pattern, p, f)
|
||
|
||
// should be impossible.
|
||
// some invalid regexp stuff in the set.
|
||
/* istanbul ignore if */
|
||
if (p === false) return false
|
||
|
||
if (p === GLOBSTAR) {
|
||
this.debug('GLOBSTAR', [pattern, p, f])
|
||
|
||
// "**"
|
||
// a/**/b/**/c would match the following:
|
||
// a/b/x/y/z/c
|
||
// a/x/y/z/b/c
|
||
// a/b/x/b/x/c
|
||
// a/b/c
|
||
// To do this, take the rest of the pattern after
|
||
// the **, and see if it would match the file remainder.
|
||
// If so, return success.
|
||
// If not, the ** "swallows" a segment, and try again.
|
||
// This is recursively awful.
|
||
//
|
||
// a/**/b/**/c matching a/b/x/y/z/c
|
||
// - a matches a
|
||
// - doublestar
|
||
// - matchOne(b/x/y/z/c, b/**/c)
|
||
// - b matches b
|
||
// - doublestar
|
||
// - matchOne(x/y/z/c, c) -> no
|
||
// - matchOne(y/z/c, c) -> no
|
||
// - matchOne(z/c, c) -> no
|
||
// - matchOne(c, c) yes, hit
|
||
var fr = fi
|
||
var pr = pi + 1
|
||
if (pr === pl) {
|
||
this.debug('** at the end')
|
||
// a ** at the end will just swallow the rest.
|
||
// We have found a match.
|
||
// however, it will not swallow /.x, unless
|
||
// options.dot is set.
|
||
// . and .. are *never* matched by **, for explosively
|
||
// exponential reasons.
|
||
for (; fi < fl; fi++) {
|
||
if (file[fi] === '.' || file[fi] === '..' ||
|
||
(!options.dot && file[fi].charAt(0) === '.')) return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// ok, let's see if we can swallow whatever we can.
|
||
while (fr < fl) {
|
||
var swallowee = file[fr]
|
||
|
||
this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
|
||
|
||
// XXX remove this slice. Just pass the start index.
|
||
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
|
||
this.debug('globstar found match!', fr, fl, swallowee)
|
||
// found a match.
|
||
return true
|
||
} else {
|
||
// can't swallow "." or ".." ever.
|
||
// can only swallow ".foo" when explicitly asked.
|
||
if (swallowee === '.' || swallowee === '..' ||
|
||
(!options.dot && swallowee.charAt(0) === '.')) {
|
||
this.debug('dot detected!', file, fr, pattern, pr)
|
||
break
|
||
}
|
||
|
||
// ** swallows a segment, and continue.
|
||
this.debug('globstar swallow a segment, and continue')
|
||
fr++
|
||
}
|
||
}
|
||
|
||
// no match was found.
|
||
// However, in partial mode, we can't say this is necessarily over.
|
||
// If there's more *pattern* left, then
|
||
/* istanbul ignore if */
|
||
if (partial) {
|
||
// ran out of file
|
||
this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
|
||
if (fr === fl) return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// something other than **
|
||
// non-magic patterns just have to match exactly
|
||
// patterns with magic have been turned into regexps.
|
||
var hit
|
||
if (typeof p === 'string') {
|
||
hit = f === p
|
||
this.debug('string match', p, f, hit)
|
||
} else {
|
||
hit = f.match(p)
|
||
this.debug('pattern match', p, f, hit)
|
||
}
|
||
|
||
if (!hit) return false
|
||
}
|
||
|
||
// Note: ending in / means that we'll get a final ""
|
||
// at the end of the pattern. This can only match a
|
||
// corresponding "" at the end of the file.
|
||
// If the file ends in /, then it can only match a
|
||
// a pattern that ends in /, unless the pattern just
|
||
// doesn't have any more for it. But, a/b/ should *not*
|
||
// match "a/b/*", even though "" matches against the
|
||
// [^/]*? pattern, except in partial mode, where it might
|
||
// simply not be reached yet.
|
||
// However, a/b/ should still satisfy a/*
|
||
|
||
// now either we fell off the end of the pattern, or we're done.
|
||
if (fi === fl && pi === pl) {
|
||
// ran out of pattern and filename at the same time.
|
||
// an exact hit!
|
||
return true
|
||
} else if (fi === fl) {
|
||
// ran out of file, but still had pattern left.
|
||
// this is ok if we're doing the match as part of
|
||
// a glob fs traversal.
|
||
return partial
|
||
} else /* istanbul ignore else */ if (pi === pl) {
|
||
// ran out of pattern, still have file left.
|
||
// this is only acceptable if we're on the very last
|
||
// empty segment of a file with a trailing slash.
|
||
// a/* should match a/b/
|
||
return (fi === fl - 1) && (file[fi] === '')
|
||
}
|
||
|
||
// should be unreachable.
|
||
/* istanbul ignore next */
|
||
throw new Error('wtf?')
|
||
}
|
||
|
||
// replace stuff like \* with *
|
||
function globUnescape (s) {
|
||
return s.replace(/\\(.)/g, '$1')
|
||
}
|
||
|
||
function regExpEscape (s) {
|
||
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 94 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = void 0;
|
||
var platform_1 = __webpack_require__(910);
|
||
var version_1 = __webpack_require__(830);
|
||
var semver_1 = __webpack_require__(987);
|
||
var major = version_1.VERSION.split('.')[0];
|
||
var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
|
||
var _global = platform_1._globalThis;
|
||
function registerGlobal(type, instance, diag, allowOverride) {
|
||
var _a;
|
||
if (allowOverride === void 0) { allowOverride = false; }
|
||
var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
|
||
version: version_1.VERSION,
|
||
});
|
||
if (!allowOverride && api[type]) {
|
||
// already registered an API of this type
|
||
var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
|
||
diag.error(err.stack || err.message);
|
||
return false;
|
||
}
|
||
if (api.version !== version_1.VERSION) {
|
||
// All registered APIs must be of the same version exactly
|
||
var err = new Error('@opentelemetry/api: All API registration versions must match');
|
||
diag.error(err.stack || err.message);
|
||
return false;
|
||
}
|
||
api[type] = instance;
|
||
diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + version_1.VERSION + ".");
|
||
return true;
|
||
}
|
||
exports.registerGlobal = registerGlobal;
|
||
function getGlobal(type) {
|
||
var _a, _b;
|
||
var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
|
||
if (!globalVersion || !semver_1.isCompatible(globalVersion)) {
|
||
return;
|
||
}
|
||
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
|
||
}
|
||
exports.getGlobal = getGlobal;
|
||
function unregisterGlobal(type, diag) {
|
||
diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + version_1.VERSION + ".");
|
||
var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
|
||
if (api) {
|
||
delete api[type];
|
||
}
|
||
}
|
||
exports.unregisterGlobal = unregisterGlobal;
|
||
//# sourceMappingURL=global-utils.js.map
|
||
|
||
/***/ }),
|
||
/* 95 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
//# sourceMappingURL=link.js.map
|
||
|
||
/***/ }),
|
||
/* 96 */,
|
||
/* 97 */
|
||
/***/ (function() {
|
||
|
||
"use strict";
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
if (typeof Symbol === undefined || !Symbol.asyncIterator) {
|
||
Symbol.asyncIterator = Symbol.for("Symbol.asyncIterator");
|
||
}
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
/***/ }),
|
||
/* 98 */,
|
||
/* 99 */,
|
||
/* 100 */,
|
||
/* 101 */,
|
||
/* 102 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// For internal use, subject to change.
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.prepareKeyValueMessage = exports.issueFileCommand = void 0;
|
||
// We use any as a valid input type
|
||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||
const fs = __importStar(__webpack_require__(747));
|
||
const os = __importStar(__webpack_require__(87));
|
||
const uuid_1 = __webpack_require__(25);
|
||
const utils_1 = __webpack_require__(82);
|
||
function issueFileCommand(command, message) {
|
||
const filePath = process.env[`GITHUB_${command}`];
|
||
if (!filePath) {
|
||
throw new Error(`Unable to find environment variable for file command ${command}`);
|
||
}
|
||
if (!fs.existsSync(filePath)) {
|
||
throw new Error(`Missing file at path: ${filePath}`);
|
||
}
|
||
fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
|
||
encoding: 'utf8'
|
||
});
|
||
}
|
||
exports.issueFileCommand = issueFileCommand;
|
||
function prepareKeyValueMessage(key, value) {
|
||
const delimiter = `ghadelimiter_${uuid_1.v4()}`;
|
||
const convertedValue = utils_1.toCommandValue(value);
|
||
// These should realistically never happen, but just in case someone finds a
|
||
// way to exploit uuid generation let's not allow keys or values that contain
|
||
// the delimiter.
|
||
if (key.includes(delimiter)) {
|
||
throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`);
|
||
}
|
||
if (convertedValue.includes(delimiter)) {
|
||
throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`);
|
||
}
|
||
return `${key}<<${delimiter}${os.EOL}${convertedValue}${os.EOL}${delimiter}`;
|
||
}
|
||
exports.prepareKeyValueMessage = prepareKeyValueMessage;
|
||
//# sourceMappingURL=file-command.js.map
|
||
|
||
/***/ }),
|
||
/* 103 */,
|
||
/* 104 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _validate = _interopRequireDefault(__webpack_require__(676));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function version(uuid) {
|
||
if (!(0, _validate.default)(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
|
||
return parseInt(uuid.substr(14, 1), 16);
|
||
}
|
||
|
||
var _default = version;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 105 */,
|
||
/* 106 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
/// <reference path="../shims-public.d.ts" />
|
||
const listenersMap = new WeakMap();
|
||
const abortedMap = new WeakMap();
|
||
/**
|
||
* An aborter instance implements AbortSignal interface, can abort HTTP requests.
|
||
*
|
||
* - Call AbortSignal.none to create a new AbortSignal instance that cannot be cancelled.
|
||
* Use `AbortSignal.none` when you are required to pass a cancellation token but the operation
|
||
* cannot or will not ever be cancelled.
|
||
*
|
||
* @example
|
||
* Abort without timeout
|
||
* ```ts
|
||
* await doAsyncWork(AbortSignal.none);
|
||
* ```
|
||
*/
|
||
class AbortSignal {
|
||
constructor() {
|
||
/**
|
||
* onabort event listener.
|
||
*/
|
||
this.onabort = null;
|
||
listenersMap.set(this, []);
|
||
abortedMap.set(this, false);
|
||
}
|
||
/**
|
||
* Status of whether aborted or not.
|
||
*
|
||
* @readonly
|
||
*/
|
||
get aborted() {
|
||
if (!abortedMap.has(this)) {
|
||
throw new TypeError("Expected `this` to be an instance of AbortSignal.");
|
||
}
|
||
return abortedMap.get(this);
|
||
}
|
||
/**
|
||
* Creates a new AbortSignal instance that will never be aborted.
|
||
*
|
||
* @readonly
|
||
*/
|
||
static get none() {
|
||
return new AbortSignal();
|
||
}
|
||
/**
|
||
* Added new "abort" event listener, only support "abort" event.
|
||
*
|
||
* @param _type - Only support "abort" event
|
||
* @param listener - The listener to be added
|
||
*/
|
||
addEventListener(
|
||
// tslint:disable-next-line:variable-name
|
||
_type, listener) {
|
||
if (!listenersMap.has(this)) {
|
||
throw new TypeError("Expected `this` to be an instance of AbortSignal.");
|
||
}
|
||
const listeners = listenersMap.get(this);
|
||
listeners.push(listener);
|
||
}
|
||
/**
|
||
* Remove "abort" event listener, only support "abort" event.
|
||
*
|
||
* @param _type - Only support "abort" event
|
||
* @param listener - The listener to be removed
|
||
*/
|
||
removeEventListener(
|
||
// tslint:disable-next-line:variable-name
|
||
_type, listener) {
|
||
if (!listenersMap.has(this)) {
|
||
throw new TypeError("Expected `this` to be an instance of AbortSignal.");
|
||
}
|
||
const listeners = listenersMap.get(this);
|
||
const index = listeners.indexOf(listener);
|
||
if (index > -1) {
|
||
listeners.splice(index, 1);
|
||
}
|
||
}
|
||
/**
|
||
* Dispatches a synthetic event to the AbortSignal.
|
||
*/
|
||
dispatchEvent(_event) {
|
||
throw new Error("This is a stub dispatchEvent implementation that should not be used. It only exists for type-checking purposes.");
|
||
}
|
||
}
|
||
/**
|
||
* Helper to trigger an abort event immediately, the onabort and all abort event listeners will be triggered.
|
||
* Will try to trigger abort event for all linked AbortSignal nodes.
|
||
*
|
||
* - If there is a timeout, the timer will be cancelled.
|
||
* - If aborted is true, nothing will happen.
|
||
*
|
||
* @internal
|
||
*/
|
||
// eslint-disable-next-line @azure/azure-sdk/ts-use-interface-parameters
|
||
function abortSignal(signal) {
|
||
if (signal.aborted) {
|
||
return;
|
||
}
|
||
if (signal.onabort) {
|
||
signal.onabort.call(signal);
|
||
}
|
||
const listeners = listenersMap.get(signal);
|
||
if (listeners) {
|
||
// Create a copy of listeners so mutations to the array
|
||
// (e.g. via removeListener calls) don't affect the listeners
|
||
// we invoke.
|
||
listeners.slice().forEach((listener) => {
|
||
listener.call(signal, { type: "abort" });
|
||
});
|
||
}
|
||
abortedMap.set(signal, true);
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
/**
|
||
* This error is thrown when an asynchronous operation has been aborted.
|
||
* Check for this error by testing the `name` that the name property of the
|
||
* error matches `"AbortError"`.
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* const controller = new AbortController();
|
||
* controller.abort();
|
||
* try {
|
||
* doAsyncWork(controller.signal)
|
||
* } catch (e) {
|
||
* if (e.name === 'AbortError') {
|
||
* // handle abort error here.
|
||
* }
|
||
* }
|
||
* ```
|
||
*/
|
||
class AbortError extends Error {
|
||
constructor(message) {
|
||
super(message);
|
||
this.name = "AbortError";
|
||
}
|
||
}
|
||
/**
|
||
* An AbortController provides an AbortSignal and the associated controls to signal
|
||
* that an asynchronous operation should be aborted.
|
||
*
|
||
* @example
|
||
* Abort an operation when another event fires
|
||
* ```ts
|
||
* const controller = new AbortController();
|
||
* const signal = controller.signal;
|
||
* doAsyncWork(signal);
|
||
* button.addEventListener('click', () => controller.abort());
|
||
* ```
|
||
*
|
||
* @example
|
||
* Share aborter cross multiple operations in 30s
|
||
* ```ts
|
||
* // Upload the same data to 2 different data centers at the same time,
|
||
* // abort another when any of them is finished
|
||
* const controller = AbortController.withTimeout(30 * 1000);
|
||
* doAsyncWork(controller.signal).then(controller.abort);
|
||
* doAsyncWork(controller.signal).then(controller.abort);
|
||
*```
|
||
*
|
||
* @example
|
||
* Cascaded aborting
|
||
* ```ts
|
||
* // All operations can't take more than 30 seconds
|
||
* const aborter = Aborter.timeout(30 * 1000);
|
||
*
|
||
* // Following 2 operations can't take more than 25 seconds
|
||
* await doAsyncWork(aborter.withTimeout(25 * 1000));
|
||
* await doAsyncWork(aborter.withTimeout(25 * 1000));
|
||
* ```
|
||
*/
|
||
class AbortController {
|
||
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
|
||
constructor(parentSignals) {
|
||
this._signal = new AbortSignal();
|
||
if (!parentSignals) {
|
||
return;
|
||
}
|
||
// coerce parentSignals into an array
|
||
if (!Array.isArray(parentSignals)) {
|
||
// eslint-disable-next-line prefer-rest-params
|
||
parentSignals = arguments;
|
||
}
|
||
for (const parentSignal of parentSignals) {
|
||
// if the parent signal has already had abort() called,
|
||
// then call abort on this signal as well.
|
||
if (parentSignal.aborted) {
|
||
this.abort();
|
||
}
|
||
else {
|
||
// when the parent signal aborts, this signal should as well.
|
||
parentSignal.addEventListener("abort", () => {
|
||
this.abort();
|
||
});
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* The AbortSignal associated with this controller that will signal aborted
|
||
* when the abort method is called on this controller.
|
||
*
|
||
* @readonly
|
||
*/
|
||
get signal() {
|
||
return this._signal;
|
||
}
|
||
/**
|
||
* Signal that any operations passed this controller's associated abort signal
|
||
* to cancel any remaining work and throw an `AbortError`.
|
||
*/
|
||
abort() {
|
||
abortSignal(this._signal);
|
||
}
|
||
/**
|
||
* Creates a new AbortSignal instance that will abort after the provided ms.
|
||
* @param ms - Elapsed time in milliseconds to trigger an abort.
|
||
*/
|
||
static timeout(ms) {
|
||
const signal = new AbortSignal();
|
||
const timer = setTimeout(abortSignal, ms, signal);
|
||
// Prevent the active Timer from keeping the Node.js event loop active.
|
||
if (typeof timer.unref === "function") {
|
||
timer.unref();
|
||
}
|
||
return signal;
|
||
}
|
||
}
|
||
|
||
exports.AbortController = AbortController;
|
||
exports.AbortError = AbortError;
|
||
exports.AbortSignal = AbortSignal;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
/* 107 */,
|
||
/* 108 */,
|
||
/* 109 */,
|
||
/* 110 */,
|
||
/* 111 */,
|
||
/* 112 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.baggageEntryMetadataFromString = exports.createBaggage = void 0;
|
||
var diag_1 = __webpack_require__(118);
|
||
var baggage_impl_1 = __webpack_require__(666);
|
||
var symbol_1 = __webpack_require__(561);
|
||
var diag = diag_1.DiagAPI.instance();
|
||
/**
|
||
* Create a new Baggage with optional entries
|
||
*
|
||
* @param entries An array of baggage entries the new baggage should contain
|
||
*/
|
||
function createBaggage(entries) {
|
||
if (entries === void 0) { entries = {}; }
|
||
return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
|
||
}
|
||
exports.createBaggage = createBaggage;
|
||
/**
|
||
* Create a serializable BaggageEntryMetadata object from a string.
|
||
*
|
||
* @param str string metadata. Format is currently not defined by the spec and has no special meaning.
|
||
*
|
||
*/
|
||
function baggageEntryMetadataFromString(str) {
|
||
if (typeof str !== 'string') {
|
||
diag.error("Cannot create baggage metadata from unknown type: " + typeof str);
|
||
str = '';
|
||
}
|
||
return {
|
||
__TYPE__: symbol_1.baggageEntryMetadataSymbol,
|
||
toString: function () {
|
||
return str;
|
||
},
|
||
};
|
||
}
|
||
exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
|
||
//# sourceMappingURL=utils.js.map
|
||
|
||
/***/ }),
|
||
/* 113 */,
|
||
/* 114 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const core = __importStar(__webpack_require__(470));
|
||
const http_client_1 = __webpack_require__(425);
|
||
const auth_1 = __webpack_require__(554);
|
||
const crypto = __importStar(__webpack_require__(417));
|
||
const fs = __importStar(__webpack_require__(747));
|
||
const url_1 = __webpack_require__(414);
|
||
const utils = __importStar(__webpack_require__(15));
|
||
const downloadUtils_1 = __webpack_require__(251);
|
||
const options_1 = __webpack_require__(538);
|
||
const requestUtils_1 = __webpack_require__(899);
|
||
const versionSalt = '1.0';
|
||
function getCacheApiUrl(resource) {
|
||
const baseUrl = process.env['ACTIONS_CACHE_URL'] || '';
|
||
if (!baseUrl) {
|
||
throw new Error('Cache Service Url not found, unable to restore cache.');
|
||
}
|
||
const url = `${baseUrl}_apis/artifactcache/${resource}`;
|
||
core.debug(`Resource Url: ${url}`);
|
||
return url;
|
||
}
|
||
function createAcceptHeader(type, apiVersion) {
|
||
return `${type};api-version=${apiVersion}`;
|
||
}
|
||
function getRequestOptions() {
|
||
const requestOptions = {
|
||
headers: {
|
||
Accept: createAcceptHeader('application/json', '6.0-preview.1')
|
||
}
|
||
};
|
||
return requestOptions;
|
||
}
|
||
function createHttpClient() {
|
||
const token = process.env['ACTIONS_RUNTIME_TOKEN'] || '';
|
||
const bearerCredentialHandler = new auth_1.BearerCredentialHandler(token);
|
||
return new http_client_1.HttpClient('actions/cache', [bearerCredentialHandler], getRequestOptions());
|
||
}
|
||
function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) {
|
||
const components = paths;
|
||
// Add compression method to cache version to restore
|
||
// compressed cache as per compression method
|
||
if (compressionMethod) {
|
||
components.push(compressionMethod);
|
||
}
|
||
// Only check for windows platforms if enableCrossOsArchive is false
|
||
if (process.platform === 'win32' && !enableCrossOsArchive) {
|
||
components.push('windows-only');
|
||
}
|
||
// Add salt to cache version to support breaking changes in cache entry
|
||
components.push(versionSalt);
|
||
return crypto
|
||
.createHash('sha256')
|
||
.update(components.join('|'))
|
||
.digest('hex');
|
||
}
|
||
exports.getCacheVersion = getCacheVersion;
|
||
function getCacheEntry(keys, paths, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const httpClient = createHttpClient();
|
||
const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive);
|
||
const resource = `cache?keys=${encodeURIComponent(keys.join(','))}&version=${version}`;
|
||
const response = yield requestUtils_1.retryTypedResponse('getCacheEntry', () => __awaiter(this, void 0, void 0, function* () { return httpClient.getJson(getCacheApiUrl(resource)); }));
|
||
// Cache not found
|
||
if (response.statusCode === 204) {
|
||
// List cache for primary key only if cache miss occurs
|
||
if (core.isDebug()) {
|
||
yield printCachesListForDiagnostics(keys[0], httpClient, version);
|
||
}
|
||
return null;
|
||
}
|
||
if (!requestUtils_1.isSuccessStatusCode(response.statusCode)) {
|
||
throw new Error(`Cache service responded with ${response.statusCode}`);
|
||
}
|
||
const cacheResult = response.result;
|
||
const cacheDownloadUrl = cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.archiveLocation;
|
||
if (!cacheDownloadUrl) {
|
||
// Cache achiveLocation not found. This should never happen, and hence bail out.
|
||
throw new Error('Cache not found.');
|
||
}
|
||
core.setSecret(cacheDownloadUrl);
|
||
core.debug(`Cache Result:`);
|
||
core.debug(JSON.stringify(cacheResult));
|
||
return cacheResult;
|
||
});
|
||
}
|
||
exports.getCacheEntry = getCacheEntry;
|
||
function printCachesListForDiagnostics(key, httpClient, version) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const resource = `caches?key=${encodeURIComponent(key)}`;
|
||
const response = yield requestUtils_1.retryTypedResponse('listCache', () => __awaiter(this, void 0, void 0, function* () { return httpClient.getJson(getCacheApiUrl(resource)); }));
|
||
if (response.statusCode === 200) {
|
||
const cacheListResult = response.result;
|
||
const totalCount = cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.totalCount;
|
||
if (totalCount && totalCount > 0) {
|
||
core.debug(`No matching cache found for cache key '${key}', version '${version} and scope ${process.env['GITHUB_REF']}. There exist one or more cache(s) with similar key but they have different version or scope. See more info on cache matching here: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key \nOther caches with similar key:`);
|
||
for (const cacheEntry of (cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.artifactCaches) || []) {
|
||
core.debug(`Cache Key: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheKey}, Cache Version: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheVersion}, Cache Scope: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.scope}, Cache Created: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.creationTime}`);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
function downloadCache(archiveLocation, archivePath, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const archiveUrl = new url_1.URL(archiveLocation);
|
||
const downloadOptions = options_1.getDownloadOptions(options);
|
||
if (downloadOptions.useAzureSdk &&
|
||
archiveUrl.hostname.endsWith('.blob.core.windows.net')) {
|
||
// Use Azure storage SDK to download caches hosted on Azure to improve speed and reliability.
|
||
yield downloadUtils_1.downloadCacheStorageSDK(archiveLocation, archivePath, downloadOptions);
|
||
}
|
||
else {
|
||
// Otherwise, download using the Actions http-client.
|
||
yield downloadUtils_1.downloadCacheHttpClient(archiveLocation, archivePath);
|
||
}
|
||
});
|
||
}
|
||
exports.downloadCache = downloadCache;
|
||
// Reserve Cache
|
||
function reserveCache(key, paths, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const httpClient = createHttpClient();
|
||
const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive);
|
||
const reserveCacheRequest = {
|
||
key,
|
||
version,
|
||
cacheSize: options === null || options === void 0 ? void 0 : options.cacheSize
|
||
};
|
||
const response = yield requestUtils_1.retryTypedResponse('reserveCache', () => __awaiter(this, void 0, void 0, function* () {
|
||
return httpClient.postJson(getCacheApiUrl('caches'), reserveCacheRequest);
|
||
}));
|
||
return response;
|
||
});
|
||
}
|
||
exports.reserveCache = reserveCache;
|
||
function getContentRange(start, end) {
|
||
// Format: `bytes start-end/filesize
|
||
// start and end are inclusive
|
||
// filesize can be *
|
||
// For a 200 byte chunk starting at byte 0:
|
||
// Content-Range: bytes 0-199/*
|
||
return `bytes ${start}-${end}/*`;
|
||
}
|
||
function uploadChunk(httpClient, resourceUrl, openStream, start, end) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
core.debug(`Uploading chunk of size ${end -
|
||
start +
|
||
1} bytes at offset ${start} with content range: ${getContentRange(start, end)}`);
|
||
const additionalHeaders = {
|
||
'Content-Type': 'application/octet-stream',
|
||
'Content-Range': getContentRange(start, end)
|
||
};
|
||
const uploadChunkResponse = yield requestUtils_1.retryHttpClientResponse(`uploadChunk (start: ${start}, end: ${end})`, () => __awaiter(this, void 0, void 0, function* () {
|
||
return httpClient.sendStream('PATCH', resourceUrl, openStream(), additionalHeaders);
|
||
}));
|
||
if (!requestUtils_1.isSuccessStatusCode(uploadChunkResponse.message.statusCode)) {
|
||
throw new Error(`Cache service responded with ${uploadChunkResponse.message.statusCode} during upload chunk.`);
|
||
}
|
||
});
|
||
}
|
||
function uploadFile(httpClient, cacheId, archivePath, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
// Upload Chunks
|
||
const fileSize = utils.getArchiveFileSizeInBytes(archivePath);
|
||
const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
|
||
const fd = fs.openSync(archivePath, 'r');
|
||
const uploadOptions = options_1.getUploadOptions(options);
|
||
const concurrency = utils.assertDefined('uploadConcurrency', uploadOptions.uploadConcurrency);
|
||
const maxChunkSize = utils.assertDefined('uploadChunkSize', uploadOptions.uploadChunkSize);
|
||
const parallelUploads = [...new Array(concurrency).keys()];
|
||
core.debug('Awaiting all uploads');
|
||
let offset = 0;
|
||
try {
|
||
yield Promise.all(parallelUploads.map(() => __awaiter(this, void 0, void 0, function* () {
|
||
while (offset < fileSize) {
|
||
const chunkSize = Math.min(fileSize - offset, maxChunkSize);
|
||
const start = offset;
|
||
const end = offset + chunkSize - 1;
|
||
offset += maxChunkSize;
|
||
yield uploadChunk(httpClient, resourceUrl, () => fs
|
||
.createReadStream(archivePath, {
|
||
fd,
|
||
start,
|
||
end,
|
||
autoClose: false
|
||
})
|
||
.on('error', error => {
|
||
throw new Error(`Cache upload failed because file read failed with ${error.message}`);
|
||
}), start, end);
|
||
}
|
||
})));
|
||
}
|
||
finally {
|
||
fs.closeSync(fd);
|
||
}
|
||
return;
|
||
});
|
||
}
|
||
function commitCache(httpClient, cacheId, filesize) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const commitCacheRequest = { size: filesize };
|
||
return yield requestUtils_1.retryTypedResponse('commitCache', () => __awaiter(this, void 0, void 0, function* () {
|
||
return httpClient.postJson(getCacheApiUrl(`caches/${cacheId.toString()}`), commitCacheRequest);
|
||
}));
|
||
});
|
||
}
|
||
function saveCache(cacheId, archivePath, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const httpClient = createHttpClient();
|
||
core.debug('Upload cache');
|
||
yield uploadFile(httpClient, cacheId, archivePath, options);
|
||
// Commit Cache
|
||
core.debug('Commiting cache');
|
||
const cacheSize = utils.getArchiveFileSizeInBytes(archivePath);
|
||
core.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`);
|
||
const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize);
|
||
if (!requestUtils_1.isSuccessStatusCode(commitCacheResponse.statusCode)) {
|
||
throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`);
|
||
}
|
||
core.info('Cache saved successfully');
|
||
});
|
||
}
|
||
exports.saveCache = saveCache;
|
||
//# sourceMappingURL=cacheHttpClient.js.map
|
||
|
||
/***/ }),
|
||
/* 115 */,
|
||
/* 116 */,
|
||
/* 117 */,
|
||
/* 118 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.DiagAPI = void 0;
|
||
var ComponentLogger_1 = __webpack_require__(362);
|
||
var logLevelLogger_1 = __webpack_require__(673);
|
||
var types_1 = __webpack_require__(545);
|
||
var global_utils_1 = __webpack_require__(94);
|
||
var API_NAME = 'diag';
|
||
/**
|
||
* Singleton object which represents the entry point to the OpenTelemetry internal
|
||
* diagnostic API
|
||
*/
|
||
var DiagAPI = /** @class */ (function () {
|
||
/**
|
||
* Private internal constructor
|
||
* @private
|
||
*/
|
||
function DiagAPI() {
|
||
function _logProxy(funcName) {
|
||
return function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
var logger = global_utils_1.getGlobal('diag');
|
||
// shortcut if logger not set
|
||
if (!logger)
|
||
return;
|
||
return logger[funcName].apply(logger, args);
|
||
};
|
||
}
|
||
// Using self local variable for minification purposes as 'this' cannot be minified
|
||
var self = this;
|
||
// DiagAPI specific functions
|
||
self.setLogger = function (logger, logLevel) {
|
||
var _a, _b;
|
||
if (logLevel === void 0) { logLevel = types_1.DiagLogLevel.INFO; }
|
||
if (logger === self) {
|
||
// There isn't much we can do here.
|
||
// Logging to the console might break the user application.
|
||
// Try to log to self. If a logger was previously registered it will receive the log.
|
||
var err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');
|
||
self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
|
||
return false;
|
||
}
|
||
var oldLogger = global_utils_1.getGlobal('diag');
|
||
var newLogger = logLevelLogger_1.createLogLevelDiagLogger(logLevel, logger);
|
||
// There already is an logger registered. We'll let it know before overwriting it.
|
||
if (oldLogger) {
|
||
var stack = (_b = new Error().stack) !== null && _b !== void 0 ? _b : '<failed to generate stacktrace>';
|
||
oldLogger.warn("Current logger will be overwritten from " + stack);
|
||
newLogger.warn("Current logger will overwrite one already registered from " + stack);
|
||
}
|
||
return global_utils_1.registerGlobal('diag', newLogger, self, true);
|
||
};
|
||
self.disable = function () {
|
||
global_utils_1.unregisterGlobal(API_NAME, self);
|
||
};
|
||
self.createComponentLogger = function (options) {
|
||
return new ComponentLogger_1.DiagComponentLogger(options);
|
||
};
|
||
self.verbose = _logProxy('verbose');
|
||
self.debug = _logProxy('debug');
|
||
self.info = _logProxy('info');
|
||
self.warn = _logProxy('warn');
|
||
self.error = _logProxy('error');
|
||
}
|
||
/** Get the singleton instance of the DiagAPI API */
|
||
DiagAPI.instance = function () {
|
||
if (!this._instance) {
|
||
this._instance = new DiagAPI();
|
||
}
|
||
return this._instance;
|
||
};
|
||
return DiagAPI;
|
||
}());
|
||
exports.DiagAPI = DiagAPI;
|
||
//# sourceMappingURL=diag.js.map
|
||
|
||
/***/ }),
|
||
/* 119 */,
|
||
/* 120 */,
|
||
/* 121 */,
|
||
/* 122 */,
|
||
/* 123 */,
|
||
/* 124 */,
|
||
/* 125 */,
|
||
/* 126 */,
|
||
/* 127 */,
|
||
/* 128 */,
|
||
/* 129 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("child_process");
|
||
|
||
/***/ }),
|
||
/* 130 */,
|
||
/* 131 */,
|
||
/* 132 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.ROOT_CONTEXT = exports.createContextKey = void 0;
|
||
/** Get a key to uniquely identify a context value */
|
||
function createContextKey(description) {
|
||
// The specification states that for the same input, multiple calls should
|
||
// return different keys. Due to the nature of the JS dependency management
|
||
// system, this creates problems where multiple versions of some package
|
||
// could hold different keys for the same property.
|
||
//
|
||
// Therefore, we use Symbol.for which returns the same key for the same input.
|
||
return Symbol.for(description);
|
||
}
|
||
exports.createContextKey = createContextKey;
|
||
var BaseContext = /** @class */ (function () {
|
||
/**
|
||
* Construct a new context which inherits values from an optional parent context.
|
||
*
|
||
* @param parentContext a context from which to inherit values
|
||
*/
|
||
function BaseContext(parentContext) {
|
||
// for minification
|
||
var self = this;
|
||
self._currentContext = parentContext ? new Map(parentContext) : new Map();
|
||
self.getValue = function (key) { return self._currentContext.get(key); };
|
||
self.setValue = function (key, value) {
|
||
var context = new BaseContext(self._currentContext);
|
||
context._currentContext.set(key, value);
|
||
return context;
|
||
};
|
||
self.deleteValue = function (key) {
|
||
var context = new BaseContext(self._currentContext);
|
||
context._currentContext.delete(key);
|
||
return context;
|
||
};
|
||
}
|
||
return BaseContext;
|
||
}());
|
||
/** The root context is used as the default parent context when there is no active context */
|
||
exports.ROOT_CONTEXT = new BaseContext();
|
||
//# sourceMappingURL=context.js.map
|
||
|
||
/***/ }),
|
||
/* 133 */,
|
||
/* 134 */,
|
||
/* 135 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _validate = _interopRequireDefault(__webpack_require__(634));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function version(uuid) {
|
||
if (!(0, _validate.default)(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
|
||
return parseInt(uuid.substr(14, 1), 16);
|
||
}
|
||
|
||
var _default = version;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 136 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = _default;
|
||
exports.URL = exports.DNS = void 0;
|
||
|
||
var _stringify = _interopRequireDefault(__webpack_require__(960));
|
||
|
||
var _parse = _interopRequireDefault(__webpack_require__(204));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function stringToBytes(str) {
|
||
str = unescape(encodeURIComponent(str)); // UTF8 escape
|
||
|
||
const bytes = [];
|
||
|
||
for (let i = 0; i < str.length; ++i) {
|
||
bytes.push(str.charCodeAt(i));
|
||
}
|
||
|
||
return bytes;
|
||
}
|
||
|
||
const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
|
||
exports.DNS = DNS;
|
||
const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
|
||
exports.URL = URL;
|
||
|
||
function _default(name, version, hashfunc) {
|
||
function generateUUID(value, namespace, buf, offset) {
|
||
if (typeof value === 'string') {
|
||
value = stringToBytes(value);
|
||
}
|
||
|
||
if (typeof namespace === 'string') {
|
||
namespace = (0, _parse.default)(namespace);
|
||
}
|
||
|
||
if (namespace.length !== 16) {
|
||
throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
|
||
} // Compute hash of namespace and value, Per 4.3
|
||
// Future: Use spread syntax when supported on all platforms, e.g. `bytes =
|
||
// hashfunc([...namespace, ... value])`
|
||
|
||
|
||
let bytes = new Uint8Array(16 + value.length);
|
||
bytes.set(namespace);
|
||
bytes.set(value, namespace.length);
|
||
bytes = hashfunc(bytes);
|
||
bytes[6] = bytes[6] & 0x0f | version;
|
||
bytes[8] = bytes[8] & 0x3f | 0x80;
|
||
|
||
if (buf) {
|
||
offset = offset || 0;
|
||
|
||
for (let i = 0; i < 16; ++i) {
|
||
buf[offset + i] = bytes[i];
|
||
}
|
||
|
||
return buf;
|
||
}
|
||
|
||
return (0, _stringify.default)(bytes);
|
||
} // Function#name is not settable on some platforms (#270)
|
||
|
||
|
||
try {
|
||
generateUUID.name = name; // eslint-disable-next-line no-empty
|
||
} catch (err) {} // For CommonJS default export support
|
||
|
||
|
||
generateUUID.DNS = DNS;
|
||
generateUUID.URL = URL;
|
||
return generateUUID;
|
||
}
|
||
|
||
/***/ }),
|
||
/* 137 */,
|
||
/* 138 */,
|
||
/* 139 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
// Unique ID creation requires a high quality random # generator. In node.js
|
||
// this is pretty straight-forward - we use the crypto API.
|
||
|
||
var crypto = __webpack_require__(417);
|
||
|
||
module.exports = function nodeRNG() {
|
||
return crypto.randomBytes(16);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 140 */,
|
||
/* 141 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var net = __webpack_require__(631);
|
||
var tls = __webpack_require__(16);
|
||
var http = __webpack_require__(605);
|
||
var https = __webpack_require__(211);
|
||
var events = __webpack_require__(614);
|
||
var assert = __webpack_require__(357);
|
||
var util = __webpack_require__(669);
|
||
|
||
|
||
exports.httpOverHttp = httpOverHttp;
|
||
exports.httpsOverHttp = httpsOverHttp;
|
||
exports.httpOverHttps = httpOverHttps;
|
||
exports.httpsOverHttps = httpsOverHttps;
|
||
|
||
|
||
function httpOverHttp(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = http.request;
|
||
return agent;
|
||
}
|
||
|
||
function httpsOverHttp(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = http.request;
|
||
agent.createSocket = createSecureSocket;
|
||
agent.defaultPort = 443;
|
||
return agent;
|
||
}
|
||
|
||
function httpOverHttps(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = https.request;
|
||
return agent;
|
||
}
|
||
|
||
function httpsOverHttps(options) {
|
||
var agent = new TunnelingAgent(options);
|
||
agent.request = https.request;
|
||
agent.createSocket = createSecureSocket;
|
||
agent.defaultPort = 443;
|
||
return agent;
|
||
}
|
||
|
||
|
||
function TunnelingAgent(options) {
|
||
var self = this;
|
||
self.options = options || {};
|
||
self.proxyOptions = self.options.proxy || {};
|
||
self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
|
||
self.requests = [];
|
||
self.sockets = [];
|
||
|
||
self.on('free', function onFree(socket, host, port, localAddress) {
|
||
var options = toOptions(host, port, localAddress);
|
||
for (var i = 0, len = self.requests.length; i < len; ++i) {
|
||
var pending = self.requests[i];
|
||
if (pending.host === options.host && pending.port === options.port) {
|
||
// Detect the request to connect same origin server,
|
||
// reuse the connection.
|
||
self.requests.splice(i, 1);
|
||
pending.request.onSocket(socket);
|
||
return;
|
||
}
|
||
}
|
||
socket.destroy();
|
||
self.removeSocket(socket);
|
||
});
|
||
}
|
||
util.inherits(TunnelingAgent, events.EventEmitter);
|
||
|
||
TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
|
||
var self = this;
|
||
var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
|
||
|
||
if (self.sockets.length >= this.maxSockets) {
|
||
// We are over limit so we'll add it to the queue.
|
||
self.requests.push(options);
|
||
return;
|
||
}
|
||
|
||
// If we are under maxSockets create a new one.
|
||
self.createSocket(options, function(socket) {
|
||
socket.on('free', onFree);
|
||
socket.on('close', onCloseOrRemove);
|
||
socket.on('agentRemove', onCloseOrRemove);
|
||
req.onSocket(socket);
|
||
|
||
function onFree() {
|
||
self.emit('free', socket, options);
|
||
}
|
||
|
||
function onCloseOrRemove(err) {
|
||
self.removeSocket(socket);
|
||
socket.removeListener('free', onFree);
|
||
socket.removeListener('close', onCloseOrRemove);
|
||
socket.removeListener('agentRemove', onCloseOrRemove);
|
||
}
|
||
});
|
||
};
|
||
|
||
TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
|
||
var self = this;
|
||
var placeholder = {};
|
||
self.sockets.push(placeholder);
|
||
|
||
var connectOptions = mergeOptions({}, self.proxyOptions, {
|
||
method: 'CONNECT',
|
||
path: options.host + ':' + options.port,
|
||
agent: false,
|
||
headers: {
|
||
host: options.host + ':' + options.port
|
||
}
|
||
});
|
||
if (options.localAddress) {
|
||
connectOptions.localAddress = options.localAddress;
|
||
}
|
||
if (connectOptions.proxyAuth) {
|
||
connectOptions.headers = connectOptions.headers || {};
|
||
connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
|
||
new Buffer(connectOptions.proxyAuth).toString('base64');
|
||
}
|
||
|
||
debug('making CONNECT request');
|
||
var connectReq = self.request(connectOptions);
|
||
connectReq.useChunkedEncodingByDefault = false; // for v0.6
|
||
connectReq.once('response', onResponse); // for v0.6
|
||
connectReq.once('upgrade', onUpgrade); // for v0.6
|
||
connectReq.once('connect', onConnect); // for v0.7 or later
|
||
connectReq.once('error', onError);
|
||
connectReq.end();
|
||
|
||
function onResponse(res) {
|
||
// Very hacky. This is necessary to avoid http-parser leaks.
|
||
res.upgrade = true;
|
||
}
|
||
|
||
function onUpgrade(res, socket, head) {
|
||
// Hacky.
|
||
process.nextTick(function() {
|
||
onConnect(res, socket, head);
|
||
});
|
||
}
|
||
|
||
function onConnect(res, socket, head) {
|
||
connectReq.removeAllListeners();
|
||
socket.removeAllListeners();
|
||
|
||
if (res.statusCode !== 200) {
|
||
debug('tunneling socket could not be established, statusCode=%d',
|
||
res.statusCode);
|
||
socket.destroy();
|
||
var error = new Error('tunneling socket could not be established, ' +
|
||
'statusCode=' + res.statusCode);
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
return;
|
||
}
|
||
if (head.length > 0) {
|
||
debug('got illegal response body from proxy');
|
||
socket.destroy();
|
||
var error = new Error('got illegal response body from proxy');
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
return;
|
||
}
|
||
debug('tunneling connection has established');
|
||
self.sockets[self.sockets.indexOf(placeholder)] = socket;
|
||
return cb(socket);
|
||
}
|
||
|
||
function onError(cause) {
|
||
connectReq.removeAllListeners();
|
||
|
||
debug('tunneling socket could not be established, cause=%s\n',
|
||
cause.message, cause.stack);
|
||
var error = new Error('tunneling socket could not be established, ' +
|
||
'cause=' + cause.message);
|
||
error.code = 'ECONNRESET';
|
||
options.request.emit('error', error);
|
||
self.removeSocket(placeholder);
|
||
}
|
||
};
|
||
|
||
TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
|
||
var pos = this.sockets.indexOf(socket)
|
||
if (pos === -1) {
|
||
return;
|
||
}
|
||
this.sockets.splice(pos, 1);
|
||
|
||
var pending = this.requests.shift();
|
||
if (pending) {
|
||
// If we have pending requests and a socket gets closed a new one
|
||
// needs to be created to take over in the pool for the one that closed.
|
||
this.createSocket(pending, function(socket) {
|
||
pending.request.onSocket(socket);
|
||
});
|
||
}
|
||
};
|
||
|
||
function createSecureSocket(options, cb) {
|
||
var self = this;
|
||
TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
|
||
var hostHeader = options.request.getHeader('host');
|
||
var tlsOptions = mergeOptions({}, self.options, {
|
||
socket: socket,
|
||
servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
|
||
});
|
||
|
||
// 0 is dummy port for v0.6
|
||
var secureSocket = tls.connect(0, tlsOptions);
|
||
self.sockets[self.sockets.indexOf(socket)] = secureSocket;
|
||
cb(secureSocket);
|
||
});
|
||
}
|
||
|
||
|
||
function toOptions(host, port, localAddress) {
|
||
if (typeof host === 'string') { // since v0.10
|
||
return {
|
||
host: host,
|
||
port: port,
|
||
localAddress: localAddress
|
||
};
|
||
}
|
||
return host; // for v0.11 or later
|
||
}
|
||
|
||
function mergeOptions(target) {
|
||
for (var i = 1, len = arguments.length; i < len; ++i) {
|
||
var overrides = arguments[i];
|
||
if (typeof overrides === 'object') {
|
||
var keys = Object.keys(overrides);
|
||
for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
|
||
var k = keys[j];
|
||
if (overrides[k] !== undefined) {
|
||
target[k] = overrides[k];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
|
||
|
||
var debug;
|
||
if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
|
||
debug = function() {
|
||
var args = Array.prototype.slice.call(arguments);
|
||
if (typeof args[0] === 'string') {
|
||
args[0] = 'TUNNEL: ' + args[0];
|
||
} else {
|
||
args.unshift('TUNNEL:');
|
||
}
|
||
console.error.apply(console, args);
|
||
}
|
||
} else {
|
||
debug = function() {};
|
||
}
|
||
exports.debug = debug; // for test
|
||
|
||
|
||
/***/ }),
|
||
/* 142 */,
|
||
/* 143 */,
|
||
/* 144 */,
|
||
/* 145 */,
|
||
/* 146 */,
|
||
/* 147 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
exports.fromCallback = function (fn) {
|
||
return Object.defineProperty(function () {
|
||
if (typeof arguments[arguments.length - 1] === 'function') fn.apply(this, arguments)
|
||
else {
|
||
return new Promise((resolve, reject) => {
|
||
arguments[arguments.length] = (err, res) => {
|
||
if (err) return reject(err)
|
||
resolve(res)
|
||
}
|
||
arguments.length++
|
||
fn.apply(this, arguments)
|
||
})
|
||
}
|
||
}, 'name', { value: fn.name })
|
||
}
|
||
|
||
exports.fromPromise = function (fn) {
|
||
return Object.defineProperty(function () {
|
||
const cb = arguments[arguments.length - 1]
|
||
if (typeof cb !== 'function') return fn.apply(this, arguments)
|
||
else fn.apply(this, arguments).then(r => cb(null, r), cb)
|
||
}, 'name', { value: fn.name })
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 148 */,
|
||
/* 149 */
|
||
/***/ (function(module) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var conversions = {};
|
||
module.exports = conversions;
|
||
|
||
function sign(x) {
|
||
return x < 0 ? -1 : 1;
|
||
}
|
||
|
||
function evenRound(x) {
|
||
// Round x to the nearest integer, choosing the even integer if it lies halfway between two.
|
||
if ((x % 1) === 0.5 && (x & 1) === 0) { // [even number].5; round down (i.e. floor)
|
||
return Math.floor(x);
|
||
} else {
|
||
return Math.round(x);
|
||
}
|
||
}
|
||
|
||
function createNumberConversion(bitLength, typeOpts) {
|
||
if (!typeOpts.unsigned) {
|
||
--bitLength;
|
||
}
|
||
const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength);
|
||
const upperBound = Math.pow(2, bitLength) - 1;
|
||
|
||
const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength);
|
||
const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1);
|
||
|
||
return function(V, opts) {
|
||
if (!opts) opts = {};
|
||
|
||
let x = +V;
|
||
|
||
if (opts.enforceRange) {
|
||
if (!Number.isFinite(x)) {
|
||
throw new TypeError("Argument is not a finite number");
|
||
}
|
||
|
||
x = sign(x) * Math.floor(Math.abs(x));
|
||
if (x < lowerBound || x > upperBound) {
|
||
throw new TypeError("Argument is not in byte range");
|
||
}
|
||
|
||
return x;
|
||
}
|
||
|
||
if (!isNaN(x) && opts.clamp) {
|
||
x = evenRound(x);
|
||
|
||
if (x < lowerBound) x = lowerBound;
|
||
if (x > upperBound) x = upperBound;
|
||
return x;
|
||
}
|
||
|
||
if (!Number.isFinite(x) || x === 0) {
|
||
return 0;
|
||
}
|
||
|
||
x = sign(x) * Math.floor(Math.abs(x));
|
||
x = x % moduloVal;
|
||
|
||
if (!typeOpts.unsigned && x >= moduloBound) {
|
||
return x - moduloVal;
|
||
} else if (typeOpts.unsigned) {
|
||
if (x < 0) {
|
||
x += moduloVal;
|
||
} else if (x === -0) { // don't return negative zero
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
return x;
|
||
}
|
||
}
|
||
|
||
conversions["void"] = function () {
|
||
return undefined;
|
||
};
|
||
|
||
conversions["boolean"] = function (val) {
|
||
return !!val;
|
||
};
|
||
|
||
conversions["byte"] = createNumberConversion(8, { unsigned: false });
|
||
conversions["octet"] = createNumberConversion(8, { unsigned: true });
|
||
|
||
conversions["short"] = createNumberConversion(16, { unsigned: false });
|
||
conversions["unsigned short"] = createNumberConversion(16, { unsigned: true });
|
||
|
||
conversions["long"] = createNumberConversion(32, { unsigned: false });
|
||
conversions["unsigned long"] = createNumberConversion(32, { unsigned: true });
|
||
|
||
conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 });
|
||
conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 });
|
||
|
||
conversions["double"] = function (V) {
|
||
const x = +V;
|
||
|
||
if (!Number.isFinite(x)) {
|
||
throw new TypeError("Argument is not a finite floating-point value");
|
||
}
|
||
|
||
return x;
|
||
};
|
||
|
||
conversions["unrestricted double"] = function (V) {
|
||
const x = +V;
|
||
|
||
if (isNaN(x)) {
|
||
throw new TypeError("Argument is NaN");
|
||
}
|
||
|
||
return x;
|
||
};
|
||
|
||
// not quite valid, but good enough for JS
|
||
conversions["float"] = conversions["double"];
|
||
conversions["unrestricted float"] = conversions["unrestricted double"];
|
||
|
||
conversions["DOMString"] = function (V, opts) {
|
||
if (!opts) opts = {};
|
||
|
||
if (opts.treatNullAsEmptyString && V === null) {
|
||
return "";
|
||
}
|
||
|
||
return String(V);
|
||
};
|
||
|
||
conversions["ByteString"] = function (V, opts) {
|
||
const x = String(V);
|
||
let c = undefined;
|
||
for (let i = 0; (c = x.codePointAt(i)) !== undefined; ++i) {
|
||
if (c > 255) {
|
||
throw new TypeError("Argument is not a valid bytestring");
|
||
}
|
||
}
|
||
|
||
return x;
|
||
};
|
||
|
||
conversions["USVString"] = function (V) {
|
||
const S = String(V);
|
||
const n = S.length;
|
||
const U = [];
|
||
for (let i = 0; i < n; ++i) {
|
||
const c = S.charCodeAt(i);
|
||
if (c < 0xD800 || c > 0xDFFF) {
|
||
U.push(String.fromCodePoint(c));
|
||
} else if (0xDC00 <= c && c <= 0xDFFF) {
|
||
U.push(String.fromCodePoint(0xFFFD));
|
||
} else {
|
||
if (i === n - 1) {
|
||
U.push(String.fromCodePoint(0xFFFD));
|
||
} else {
|
||
const d = S.charCodeAt(i + 1);
|
||
if (0xDC00 <= d && d <= 0xDFFF) {
|
||
const a = c & 0x3FF;
|
||
const b = d & 0x3FF;
|
||
U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b));
|
||
++i;
|
||
} else {
|
||
U.push(String.fromCodePoint(0xFFFD));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return U.join('');
|
||
};
|
||
|
||
conversions["Date"] = function (V, opts) {
|
||
if (!(V instanceof Date)) {
|
||
throw new TypeError("Argument is not a Date object");
|
||
}
|
||
if (isNaN(V)) {
|
||
return undefined;
|
||
}
|
||
|
||
return V;
|
||
};
|
||
|
||
conversions["RegExp"] = function (V, opts) {
|
||
if (!(V instanceof RegExp)) {
|
||
V = new RegExp(V);
|
||
}
|
||
|
||
return V;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 150 */,
|
||
/* 151 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.NoopTracer = void 0;
|
||
var context_1 = __webpack_require__(492);
|
||
var context_utils_1 = __webpack_require__(720);
|
||
var NonRecordingSpan_1 = __webpack_require__(437);
|
||
var spancontext_utils_1 = __webpack_require__(629);
|
||
var context = context_1.ContextAPI.getInstance();
|
||
/**
|
||
* No-op implementations of {@link Tracer}.
|
||
*/
|
||
var NoopTracer = /** @class */ (function () {
|
||
function NoopTracer() {
|
||
}
|
||
// startSpan starts a noop span.
|
||
NoopTracer.prototype.startSpan = function (name, options, context) {
|
||
var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
|
||
if (root) {
|
||
return new NonRecordingSpan_1.NonRecordingSpan();
|
||
}
|
||
var parentFromContext = context && context_utils_1.getSpanContext(context);
|
||
if (isSpanContext(parentFromContext) &&
|
||
spancontext_utils_1.isSpanContextValid(parentFromContext)) {
|
||
return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
|
||
}
|
||
else {
|
||
return new NonRecordingSpan_1.NonRecordingSpan();
|
||
}
|
||
};
|
||
NoopTracer.prototype.startActiveSpan = function (name, arg2, arg3, arg4) {
|
||
var opts;
|
||
var ctx;
|
||
var fn;
|
||
if (arguments.length < 2) {
|
||
return;
|
||
}
|
||
else if (arguments.length === 2) {
|
||
fn = arg2;
|
||
}
|
||
else if (arguments.length === 3) {
|
||
opts = arg2;
|
||
fn = arg3;
|
||
}
|
||
else {
|
||
opts = arg2;
|
||
ctx = arg3;
|
||
fn = arg4;
|
||
}
|
||
var parentContext = ctx !== null && ctx !== void 0 ? ctx : context.active();
|
||
var span = this.startSpan(name, opts, parentContext);
|
||
var contextWithSpanSet = context_utils_1.setSpan(parentContext, span);
|
||
return context.with(contextWithSpanSet, fn, undefined, span);
|
||
};
|
||
return NoopTracer;
|
||
}());
|
||
exports.NoopTracer = NoopTracer;
|
||
function isSpanContext(spanContext) {
|
||
return (typeof spanContext === 'object' &&
|
||
typeof spanContext['spanId'] === 'string' &&
|
||
typeof spanContext['traceId'] === 'string' &&
|
||
typeof spanContext['traceFlags'] === 'number');
|
||
}
|
||
//# sourceMappingURL=NoopTracer.js.map
|
||
|
||
/***/ }),
|
||
/* 152 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var Stream = __webpack_require__(794).Stream;
|
||
var util = __webpack_require__(669);
|
||
|
||
module.exports = DelayedStream;
|
||
function DelayedStream() {
|
||
this.source = null;
|
||
this.dataSize = 0;
|
||
this.maxDataSize = 1024 * 1024;
|
||
this.pauseStream = true;
|
||
|
||
this._maxDataSizeExceeded = false;
|
||
this._released = false;
|
||
this._bufferedEvents = [];
|
||
}
|
||
util.inherits(DelayedStream, Stream);
|
||
|
||
DelayedStream.create = function(source, options) {
|
||
var delayedStream = new this();
|
||
|
||
options = options || {};
|
||
for (var option in options) {
|
||
delayedStream[option] = options[option];
|
||
}
|
||
|
||
delayedStream.source = source;
|
||
|
||
var realEmit = source.emit;
|
||
source.emit = function() {
|
||
delayedStream._handleEmit(arguments);
|
||
return realEmit.apply(source, arguments);
|
||
};
|
||
|
||
source.on('error', function() {});
|
||
if (delayedStream.pauseStream) {
|
||
source.pause();
|
||
}
|
||
|
||
return delayedStream;
|
||
};
|
||
|
||
Object.defineProperty(DelayedStream.prototype, 'readable', {
|
||
configurable: true,
|
||
enumerable: true,
|
||
get: function() {
|
||
return this.source.readable;
|
||
}
|
||
});
|
||
|
||
DelayedStream.prototype.setEncoding = function() {
|
||
return this.source.setEncoding.apply(this.source, arguments);
|
||
};
|
||
|
||
DelayedStream.prototype.resume = function() {
|
||
if (!this._released) {
|
||
this.release();
|
||
}
|
||
|
||
this.source.resume();
|
||
};
|
||
|
||
DelayedStream.prototype.pause = function() {
|
||
this.source.pause();
|
||
};
|
||
|
||
DelayedStream.prototype.release = function() {
|
||
this._released = true;
|
||
|
||
this._bufferedEvents.forEach(function(args) {
|
||
this.emit.apply(this, args);
|
||
}.bind(this));
|
||
this._bufferedEvents = [];
|
||
};
|
||
|
||
DelayedStream.prototype.pipe = function() {
|
||
var r = Stream.prototype.pipe.apply(this, arguments);
|
||
this.resume();
|
||
return r;
|
||
};
|
||
|
||
DelayedStream.prototype._handleEmit = function(args) {
|
||
if (this._released) {
|
||
this.emit.apply(this, args);
|
||
return;
|
||
}
|
||
|
||
if (args[0] === 'data') {
|
||
this.dataSize += args[1].length;
|
||
this._checkIfMaxDataSizeExceeded();
|
||
}
|
||
|
||
this._bufferedEvents.push(args);
|
||
};
|
||
|
||
DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
|
||
if (this._maxDataSizeExceeded) {
|
||
return;
|
||
}
|
||
|
||
if (this.dataSize <= this.maxDataSize) {
|
||
return;
|
||
}
|
||
|
||
this._maxDataSizeExceeded = true;
|
||
var message =
|
||
'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.'
|
||
this.emit('error', new Error(message));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 153 */,
|
||
/* 154 */,
|
||
/* 155 */,
|
||
/* 156 */,
|
||
/* 157 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var async = __webpack_require__(751)
|
||
, abort = __webpack_require__(566)
|
||
;
|
||
|
||
// API
|
||
module.exports = iterate;
|
||
|
||
/**
|
||
* Iterates over each job object
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {object} state - current job status
|
||
* @param {function} callback - invoked when all elements processed
|
||
*/
|
||
function iterate(list, iterator, state, callback)
|
||
{
|
||
// store current index
|
||
var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
|
||
|
||
state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
|
||
{
|
||
// don't repeat yourself
|
||
// skip secondary callbacks
|
||
if (!(key in state.jobs))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// clean up jobs
|
||
delete state.jobs[key];
|
||
|
||
if (error)
|
||
{
|
||
// don't process rest of the results
|
||
// stop still active jobs
|
||
// and reset the list
|
||
abort(state);
|
||
}
|
||
else
|
||
{
|
||
state.results[key] = output;
|
||
}
|
||
|
||
// return salvaged results
|
||
callback(error, state.results);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Runs iterator over provided job element
|
||
*
|
||
* @param {function} iterator - iterator to invoke
|
||
* @param {string|number} key - key/index of the element in the list of jobs
|
||
* @param {mixed} item - job description
|
||
* @param {function} callback - invoked after iterator is done with the job
|
||
* @returns {function|mixed} - job abort function or something else
|
||
*/
|
||
function runJob(iterator, key, item, callback)
|
||
{
|
||
var aborter;
|
||
|
||
// allow shortcut if iterator expects only two arguments
|
||
if (iterator.length == 2)
|
||
{
|
||
aborter = iterator(item, async(callback));
|
||
}
|
||
// otherwise go with full three arguments
|
||
else
|
||
{
|
||
aborter = iterator(item, key, async(callback));
|
||
}
|
||
|
||
return aborter;
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 158 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
//# sourceMappingURL=Time.js.map
|
||
|
||
/***/ }),
|
||
/* 159 */,
|
||
/* 160 */,
|
||
/* 161 */,
|
||
/* 162 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.NoopTracerProvider = void 0;
|
||
var NoopTracer_1 = __webpack_require__(151);
|
||
/**
|
||
* An implementation of the {@link TracerProvider} which returns an impotent
|
||
* Tracer for all calls to `getTracer`.
|
||
*
|
||
* All operations are no-op.
|
||
*/
|
||
var NoopTracerProvider = /** @class */ (function () {
|
||
function NoopTracerProvider() {
|
||
}
|
||
NoopTracerProvider.prototype.getTracer = function (_name, _version) {
|
||
return new NoopTracer_1.NoopTracer();
|
||
};
|
||
return NoopTracerProvider;
|
||
}());
|
||
exports.NoopTracerProvider = NoopTracerProvider;
|
||
//# sourceMappingURL=NoopTracerProvider.js.map
|
||
|
||
/***/ }),
|
||
/* 163 */,
|
||
/* 164 */,
|
||
/* 165 */,
|
||
/* 166 */,
|
||
/* 167 */,
|
||
/* 168 */,
|
||
/* 169 */,
|
||
/* 170 */,
|
||
/* 171 */,
|
||
/* 172 */,
|
||
/* 173 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _rng = _interopRequireDefault(__webpack_require__(733));
|
||
|
||
var _stringify = _interopRequireDefault(__webpack_require__(855));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
// **`v1()` - Generate time-based UUID**
|
||
//
|
||
// Inspired by https://github.com/LiosK/UUID.js
|
||
// and http://docs.python.org/library/uuid.html
|
||
let _nodeId;
|
||
|
||
let _clockseq; // Previous uuid creation time
|
||
|
||
|
||
let _lastMSecs = 0;
|
||
let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
|
||
|
||
function v1(options, buf, offset) {
|
||
let i = buf && offset || 0;
|
||
const b = buf || new Array(16);
|
||
options = options || {};
|
||
let node = options.node || _nodeId;
|
||
let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
|
||
// specified. We do this lazily to minimize issues related to insufficient
|
||
// system entropy. See #189
|
||
|
||
if (node == null || clockseq == null) {
|
||
const seedBytes = options.random || (options.rng || _rng.default)();
|
||
|
||
if (node == null) {
|
||
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
|
||
node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
|
||
}
|
||
|
||
if (clockseq == null) {
|
||
// Per 4.2.2, randomize (14 bit) clockseq
|
||
clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
|
||
}
|
||
} // UUID timestamps are 100 nano-second units since the Gregorian epoch,
|
||
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
|
||
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
|
||
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
|
||
|
||
|
||
let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
|
||
// cycle to simulate higher resolution clock
|
||
|
||
let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
|
||
|
||
const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
|
||
|
||
if (dt < 0 && options.clockseq === undefined) {
|
||
clockseq = clockseq + 1 & 0x3fff;
|
||
} // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
|
||
// time interval
|
||
|
||
|
||
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
|
||
nsecs = 0;
|
||
} // Per 4.2.1.2 Throw error if too many uuids are requested
|
||
|
||
|
||
if (nsecs >= 10000) {
|
||
throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
|
||
}
|
||
|
||
_lastMSecs = msecs;
|
||
_lastNSecs = nsecs;
|
||
_clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
|
||
|
||
msecs += 12219292800000; // `time_low`
|
||
|
||
const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
|
||
b[i++] = tl >>> 24 & 0xff;
|
||
b[i++] = tl >>> 16 & 0xff;
|
||
b[i++] = tl >>> 8 & 0xff;
|
||
b[i++] = tl & 0xff; // `time_mid`
|
||
|
||
const tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
|
||
b[i++] = tmh >>> 8 & 0xff;
|
||
b[i++] = tmh & 0xff; // `time_high_and_version`
|
||
|
||
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
|
||
|
||
b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
|
||
|
||
b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
|
||
|
||
b[i++] = clockseq & 0xff; // `node`
|
||
|
||
for (let n = 0; n < 6; ++n) {
|
||
b[i + n] = node[n];
|
||
}
|
||
|
||
return buf || (0, _stringify.default)(b);
|
||
}
|
||
|
||
var _default = v1;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 174 */,
|
||
/* 175 */,
|
||
/* 176 */,
|
||
/* 177 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.checkBypass = exports.getProxyUrl = void 0;
|
||
function getProxyUrl(reqUrl) {
|
||
const usingSsl = reqUrl.protocol === 'https:';
|
||
if (checkBypass(reqUrl)) {
|
||
return undefined;
|
||
}
|
||
const proxyVar = (() => {
|
||
if (usingSsl) {
|
||
return process.env['https_proxy'] || process.env['HTTPS_PROXY'];
|
||
}
|
||
else {
|
||
return process.env['http_proxy'] || process.env['HTTP_PROXY'];
|
||
}
|
||
})();
|
||
if (proxyVar) {
|
||
return new URL(proxyVar);
|
||
}
|
||
else {
|
||
return undefined;
|
||
}
|
||
}
|
||
exports.getProxyUrl = getProxyUrl;
|
||
function checkBypass(reqUrl) {
|
||
if (!reqUrl.hostname) {
|
||
return false;
|
||
}
|
||
const noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
|
||
if (!noProxy) {
|
||
return false;
|
||
}
|
||
// Determine the request port
|
||
let reqPort;
|
||
if (reqUrl.port) {
|
||
reqPort = Number(reqUrl.port);
|
||
}
|
||
else if (reqUrl.protocol === 'http:') {
|
||
reqPort = 80;
|
||
}
|
||
else if (reqUrl.protocol === 'https:') {
|
||
reqPort = 443;
|
||
}
|
||
// Format the request hostname and hostname with port
|
||
const upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
||
if (typeof reqPort === 'number') {
|
||
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
||
}
|
||
// Compare request host against noproxy
|
||
for (const upperNoProxyItem of noProxy
|
||
.split(',')
|
||
.map(x => x.trim().toUpperCase())
|
||
.filter(x => x)) {
|
||
if (upperReqHosts.some(x => x === upperNoProxyItem)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
exports.checkBypass = checkBypass;
|
||
//# sourceMappingURL=proxy.js.map
|
||
|
||
/***/ }),
|
||
/* 178 */,
|
||
/* 179 */,
|
||
/* 180 */,
|
||
/* 181 */,
|
||
/* 182 */,
|
||
/* 183 */,
|
||
/* 184 */,
|
||
/* 185 */,
|
||
/* 186 */,
|
||
/* 187 */,
|
||
/* 188 */,
|
||
/* 189 */,
|
||
/* 190 */,
|
||
/* 191 */,
|
||
/* 192 */,
|
||
/* 193 */,
|
||
/* 194 */,
|
||
/* 195 */,
|
||
/* 196 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.RefKey = exports.Events = exports.State = exports.Outputs = exports.Inputs = void 0;
|
||
var Inputs;
|
||
(function (Inputs) {
|
||
Inputs["Key"] = "key";
|
||
Inputs["Path"] = "path";
|
||
Inputs["RestoreKeys"] = "restore-keys";
|
||
Inputs["UploadChunkSize"] = "upload-chunk-size";
|
||
Inputs["EnableCrossOsArchive"] = "enableCrossOsArchive";
|
||
Inputs["FailOnCacheMiss"] = "fail-on-cache-miss"; // Input for cache, restore action
|
||
})(Inputs = exports.Inputs || (exports.Inputs = {}));
|
||
var Outputs;
|
||
(function (Outputs) {
|
||
Outputs["CacheHit"] = "cache-hit";
|
||
Outputs["CachePrimaryKey"] = "cache-primary-key";
|
||
Outputs["CacheMatchedKey"] = "cache-matched-key"; // Output from restore action
|
||
})(Outputs = exports.Outputs || (exports.Outputs = {}));
|
||
var State;
|
||
(function (State) {
|
||
State["CachePrimaryKey"] = "CACHE_KEY";
|
||
State["CacheMatchedKey"] = "CACHE_RESULT";
|
||
})(State = exports.State || (exports.State = {}));
|
||
var Events;
|
||
(function (Events) {
|
||
Events["Key"] = "GITHUB_EVENT_NAME";
|
||
Events["Push"] = "push";
|
||
Events["PullRequest"] = "pull_request";
|
||
})(Events = exports.Events || (exports.Events = {}));
|
||
exports.RefKey = "GITHUB_REF";
|
||
|
||
|
||
/***/ }),
|
||
/* 197 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _validate = _interopRequireDefault(__webpack_require__(676));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function parse(uuid) {
|
||
if (!(0, _validate.default)(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
|
||
let v;
|
||
const arr = new Uint8Array(16); // Parse ########-....-....-....-............
|
||
|
||
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
|
||
arr[1] = v >>> 16 & 0xff;
|
||
arr[2] = v >>> 8 & 0xff;
|
||
arr[3] = v & 0xff; // Parse ........-####-....-....-............
|
||
|
||
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
|
||
arr[5] = v & 0xff; // Parse ........-....-####-....-............
|
||
|
||
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
|
||
arr[7] = v & 0xff; // Parse ........-....-....-####-............
|
||
|
||
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
|
||
arr[9] = v & 0xff; // Parse ........-....-....-....-############
|
||
// (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
|
||
|
||
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
|
||
arr[11] = v / 0x100000000 & 0xff;
|
||
arr[12] = v >>> 24 & 0xff;
|
||
arr[13] = v >>> 16 & 0xff;
|
||
arr[14] = v >>> 8 & 0xff;
|
||
arr[15] = v & 0xff;
|
||
return arr;
|
||
}
|
||
|
||
var _default = parse;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 198 */,
|
||
/* 199 */,
|
||
/* 200 */,
|
||
/* 201 */,
|
||
/* 202 */,
|
||
/* 203 */,
|
||
/* 204 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _validate = _interopRequireDefault(__webpack_require__(634));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function parse(uuid) {
|
||
if (!(0, _validate.default)(uuid)) {
|
||
throw TypeError('Invalid UUID');
|
||
}
|
||
|
||
let v;
|
||
const arr = new Uint8Array(16); // Parse ########-....-....-....-............
|
||
|
||
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
|
||
arr[1] = v >>> 16 & 0xff;
|
||
arr[2] = v >>> 8 & 0xff;
|
||
arr[3] = v & 0xff; // Parse ........-####-....-....-............
|
||
|
||
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
|
||
arr[5] = v & 0xff; // Parse ........-....-####-....-............
|
||
|
||
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
|
||
arr[7] = v & 0xff; // Parse ........-....-....-####-............
|
||
|
||
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
|
||
arr[9] = v & 0xff; // Parse ........-....-....-....-############
|
||
// (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
|
||
|
||
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
|
||
arr[11] = v / 0x100000000 & 0xff;
|
||
arr[12] = v >>> 24 & 0xff;
|
||
arr[13] = v >>> 16 & 0xff;
|
||
arr[14] = v >>> 8 & 0xff;
|
||
arr[15] = v & 0xff;
|
||
return arr;
|
||
}
|
||
|
||
var _default = parse;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 205 */,
|
||
/* 206 */,
|
||
/* 207 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
//# sourceMappingURL=trace_state.js.map
|
||
|
||
/***/ }),
|
||
/* 208 */,
|
||
/* 209 */,
|
||
/* 210 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
"use strict";
|
||
exports.stripBOM = function(str) {
|
||
if (str[0] === '\uFEFF') {
|
||
return str.substring(1);
|
||
} else {
|
||
return str;
|
||
}
|
||
};
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 211 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("https");
|
||
|
||
/***/ }),
|
||
/* 212 */,
|
||
/* 213 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("timers");
|
||
|
||
/***/ }),
|
||
/* 214 */,
|
||
/* 215 */,
|
||
/* 216 */,
|
||
/* 217 */,
|
||
/* 218 */,
|
||
/* 219 */,
|
||
/* 220 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
//# sourceMappingURL=SpanOptions.js.map
|
||
|
||
/***/ }),
|
||
/* 221 */,
|
||
/* 222 */,
|
||
/* 223 */,
|
||
/* 224 */,
|
||
/* 225 */,
|
||
/* 226 */,
|
||
/* 227 */,
|
||
/* 228 */,
|
||
/* 229 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
/**
|
||
* A static-key-based credential that supports updating
|
||
* the underlying key value.
|
||
*/
|
||
class AzureKeyCredential {
|
||
/**
|
||
* Create an instance of an AzureKeyCredential for use
|
||
* with a service client.
|
||
*
|
||
* @param key - The initial value of the key to use in authentication
|
||
*/
|
||
constructor(key) {
|
||
if (!key) {
|
||
throw new Error("key must be a non-empty string");
|
||
}
|
||
this._key = key;
|
||
}
|
||
/**
|
||
* The value of the key to be used in authentication
|
||
*/
|
||
get key() {
|
||
return this._key;
|
||
}
|
||
/**
|
||
* Change the value of the key.
|
||
*
|
||
* Updates will take effect upon the next request after
|
||
* updating the key value.
|
||
*
|
||
* @param newKey - The new key value to be used
|
||
*/
|
||
update(newKey) {
|
||
this._key = newKey;
|
||
}
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
/**
|
||
* Helper TypeGuard that checks if something is defined or not.
|
||
* @param thing - Anything
|
||
* @internal
|
||
*/
|
||
function isDefined(thing) {
|
||
return typeof thing !== "undefined" && thing !== null;
|
||
}
|
||
/**
|
||
* Helper TypeGuard that checks if the input is an object with the specified properties.
|
||
* Note: The properties may be inherited.
|
||
* @param thing - Anything.
|
||
* @param properties - The name of the properties that should appear in the object.
|
||
* @internal
|
||
*/
|
||
function isObjectWithProperties(thing, properties) {
|
||
if (!isDefined(thing) || typeof thing !== "object") {
|
||
return false;
|
||
}
|
||
for (const property of properties) {
|
||
if (!objectHasProperty(thing, property)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
/**
|
||
* Helper TypeGuard that checks if the input is an object with the specified property.
|
||
* Note: The property may be inherited.
|
||
* @param thing - Any object.
|
||
* @param property - The name of the property that should appear in the object.
|
||
* @internal
|
||
*/
|
||
function objectHasProperty(thing, property) {
|
||
return typeof thing === "object" && property in thing;
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
/**
|
||
* A static name/key-based credential that supports updating
|
||
* the underlying name and key values.
|
||
*/
|
||
class AzureNamedKeyCredential {
|
||
/**
|
||
* Create an instance of an AzureNamedKeyCredential for use
|
||
* with a service client.
|
||
*
|
||
* @param name - The initial value of the name to use in authentication.
|
||
* @param key - The initial value of the key to use in authentication.
|
||
*/
|
||
constructor(name, key) {
|
||
if (!name || !key) {
|
||
throw new TypeError("name and key must be non-empty strings");
|
||
}
|
||
this._name = name;
|
||
this._key = key;
|
||
}
|
||
/**
|
||
* The value of the key to be used in authentication.
|
||
*/
|
||
get key() {
|
||
return this._key;
|
||
}
|
||
/**
|
||
* The value of the name to be used in authentication.
|
||
*/
|
||
get name() {
|
||
return this._name;
|
||
}
|
||
/**
|
||
* Change the value of the key.
|
||
*
|
||
* Updates will take effect upon the next request after
|
||
* updating the key value.
|
||
*
|
||
* @param newName - The new name value to be used.
|
||
* @param newKey - The new key value to be used.
|
||
*/
|
||
update(newName, newKey) {
|
||
if (!newName || !newKey) {
|
||
throw new TypeError("newName and newKey must be non-empty strings");
|
||
}
|
||
this._name = newName;
|
||
this._key = newKey;
|
||
}
|
||
}
|
||
/**
|
||
* Tests an object to determine whether it implements NamedKeyCredential.
|
||
*
|
||
* @param credential - The assumed NamedKeyCredential to be tested.
|
||
*/
|
||
function isNamedKeyCredential(credential) {
|
||
return (isObjectWithProperties(credential, ["name", "key"]) &&
|
||
typeof credential.key === "string" &&
|
||
typeof credential.name === "string");
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
/**
|
||
* A static-signature-based credential that supports updating
|
||
* the underlying signature value.
|
||
*/
|
||
class AzureSASCredential {
|
||
/**
|
||
* Create an instance of an AzureSASCredential for use
|
||
* with a service client.
|
||
*
|
||
* @param signature - The initial value of the shared access signature to use in authentication
|
||
*/
|
||
constructor(signature) {
|
||
if (!signature) {
|
||
throw new Error("shared access signature must be a non-empty string");
|
||
}
|
||
this._signature = signature;
|
||
}
|
||
/**
|
||
* The value of the shared access signature to be used in authentication
|
||
*/
|
||
get signature() {
|
||
return this._signature;
|
||
}
|
||
/**
|
||
* Change the value of the signature.
|
||
*
|
||
* Updates will take effect upon the next request after
|
||
* updating the signature value.
|
||
*
|
||
* @param newSignature - The new shared access signature value to be used
|
||
*/
|
||
update(newSignature) {
|
||
if (!newSignature) {
|
||
throw new Error("shared access signature must be a non-empty string");
|
||
}
|
||
this._signature = newSignature;
|
||
}
|
||
}
|
||
/**
|
||
* Tests an object to determine whether it implements SASCredential.
|
||
*
|
||
* @param credential - The assumed SASCredential to be tested.
|
||
*/
|
||
function isSASCredential(credential) {
|
||
return (isObjectWithProperties(credential, ["signature"]) && typeof credential.signature === "string");
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
/**
|
||
* Tests an object to determine whether it implements TokenCredential.
|
||
*
|
||
* @param credential - The assumed TokenCredential to be tested.
|
||
*/
|
||
function isTokenCredential(credential) {
|
||
// Check for an object with a 'getToken' function and possibly with
|
||
// a 'signRequest' function. We do this check to make sure that
|
||
// a ServiceClientCredentials implementor (like TokenClientCredentials
|
||
// in ms-rest-nodeauth) doesn't get mistaken for a TokenCredential if
|
||
// it doesn't actually implement TokenCredential also.
|
||
const castCredential = credential;
|
||
return (castCredential &&
|
||
typeof castCredential.getToken === "function" &&
|
||
(castCredential.signRequest === undefined || castCredential.getToken.length > 0));
|
||
}
|
||
|
||
exports.AzureKeyCredential = AzureKeyCredential;
|
||
exports.AzureNamedKeyCredential = AzureNamedKeyCredential;
|
||
exports.AzureSASCredential = AzureSASCredential;
|
||
exports.isNamedKeyCredential = isNamedKeyCredential;
|
||
exports.isSASCredential = isSASCredential;
|
||
exports.isTokenCredential = isTokenCredential;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
/* 230 */,
|
||
/* 231 */,
|
||
/* 232 */,
|
||
/* 233 */,
|
||
/* 234 */,
|
||
/* 235 */,
|
||
/* 236 */,
|
||
/* 237 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.DiagConsoleLogger = void 0;
|
||
var consoleMap = [
|
||
{ n: 'error', c: 'error' },
|
||
{ n: 'warn', c: 'warn' },
|
||
{ n: 'info', c: 'info' },
|
||
{ n: 'debug', c: 'debug' },
|
||
{ n: 'verbose', c: 'trace' },
|
||
];
|
||
/**
|
||
* A simple Immutable Console based diagnostic logger which will output any messages to the Console.
|
||
* If you want to limit the amount of logging to a specific level or lower use the
|
||
* {@link createLogLevelDiagLogger}
|
||
*/
|
||
var DiagConsoleLogger = /** @class */ (function () {
|
||
function DiagConsoleLogger() {
|
||
function _consoleFunc(funcName) {
|
||
return function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
if (console) {
|
||
// Some environments only expose the console when the F12 developer console is open
|
||
// eslint-disable-next-line no-console
|
||
var theFunc = console[funcName];
|
||
if (typeof theFunc !== 'function') {
|
||
// Not all environments support all functions
|
||
// eslint-disable-next-line no-console
|
||
theFunc = console.log;
|
||
}
|
||
// One last final check
|
||
if (typeof theFunc === 'function') {
|
||
return theFunc.apply(console, args);
|
||
}
|
||
}
|
||
};
|
||
}
|
||
for (var i = 0; i < consoleMap.length; i++) {
|
||
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
|
||
}
|
||
}
|
||
return DiagConsoleLogger;
|
||
}());
|
||
exports.DiagConsoleLogger = DiagConsoleLogger;
|
||
//# sourceMappingURL=consoleLogger.js.map
|
||
|
||
/***/ }),
|
||
/* 238 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 239 */,
|
||
/* 240 */,
|
||
/* 241 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = _default;
|
||
exports.URL = exports.DNS = void 0;
|
||
|
||
var _stringify = _interopRequireDefault(__webpack_require__(855));
|
||
|
||
var _parse = _interopRequireDefault(__webpack_require__(197));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function stringToBytes(str) {
|
||
str = unescape(encodeURIComponent(str)); // UTF8 escape
|
||
|
||
const bytes = [];
|
||
|
||
for (let i = 0; i < str.length; ++i) {
|
||
bytes.push(str.charCodeAt(i));
|
||
}
|
||
|
||
return bytes;
|
||
}
|
||
|
||
const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
|
||
exports.DNS = DNS;
|
||
const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
|
||
exports.URL = URL;
|
||
|
||
function _default(name, version, hashfunc) {
|
||
function generateUUID(value, namespace, buf, offset) {
|
||
if (typeof value === 'string') {
|
||
value = stringToBytes(value);
|
||
}
|
||
|
||
if (typeof namespace === 'string') {
|
||
namespace = (0, _parse.default)(namespace);
|
||
}
|
||
|
||
if (namespace.length !== 16) {
|
||
throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
|
||
} // Compute hash of namespace and value, Per 4.3
|
||
// Future: Use spread syntax when supported on all platforms, e.g. `bytes =
|
||
// hashfunc([...namespace, ... value])`
|
||
|
||
|
||
let bytes = new Uint8Array(16 + value.length);
|
||
bytes.set(namespace);
|
||
bytes.set(value, namespace.length);
|
||
bytes = hashfunc(bytes);
|
||
bytes[6] = bytes[6] & 0x0f | version;
|
||
bytes[8] = bytes[8] & 0x3f | 0x80;
|
||
|
||
if (buf) {
|
||
offset = offset || 0;
|
||
|
||
for (let i = 0; i < 16; ++i) {
|
||
buf[offset + i] = bytes[i];
|
||
}
|
||
|
||
return buf;
|
||
}
|
||
|
||
return (0, _stringify.default)(bytes);
|
||
} // Function#name is not settable on some platforms (#270)
|
||
|
||
|
||
try {
|
||
generateUUID.name = name; // eslint-disable-next-line no-empty
|
||
} catch (err) {} // For CommonJS default export support
|
||
|
||
|
||
generateUUID.DNS = DNS;
|
||
generateUUID.URL = URL;
|
||
return generateUUID;
|
||
}
|
||
|
||
/***/ }),
|
||
/* 242 */,
|
||
/* 243 */,
|
||
/* 244 */,
|
||
/* 245 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _crypto = _interopRequireDefault(__webpack_require__(417));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function md5(bytes) {
|
||
if (Array.isArray(bytes)) {
|
||
bytes = Buffer.from(bytes);
|
||
} else if (typeof bytes === 'string') {
|
||
bytes = Buffer.from(bytes, 'utf8');
|
||
}
|
||
|
||
return _crypto.default.createHash('md5').update(bytes).digest();
|
||
}
|
||
|
||
var _default = md5;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 246 */,
|
||
/* 247 */,
|
||
/* 248 */,
|
||
/* 249 */,
|
||
/* 250 */,
|
||
/* 251 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const core = __importStar(__webpack_require__(470));
|
||
const http_client_1 = __webpack_require__(425);
|
||
const storage_blob_1 = __webpack_require__(373);
|
||
const buffer = __importStar(__webpack_require__(407));
|
||
const fs = __importStar(__webpack_require__(747));
|
||
const stream = __importStar(__webpack_require__(794));
|
||
const util = __importStar(__webpack_require__(669));
|
||
const utils = __importStar(__webpack_require__(15));
|
||
const constants_1 = __webpack_require__(931);
|
||
const requestUtils_1 = __webpack_require__(899);
|
||
const abort_controller_1 = __webpack_require__(106);
|
||
/**
|
||
* Pipes the body of a HTTP response to a stream
|
||
*
|
||
* @param response the HTTP response
|
||
* @param output the writable stream
|
||
*/
|
||
function pipeResponseToStream(response, output) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const pipeline = util.promisify(stream.pipeline);
|
||
yield pipeline(response.message, output);
|
||
});
|
||
}
|
||
/**
|
||
* Class for tracking the download state and displaying stats.
|
||
*/
|
||
class DownloadProgress {
|
||
constructor(contentLength) {
|
||
this.contentLength = contentLength;
|
||
this.segmentIndex = 0;
|
||
this.segmentSize = 0;
|
||
this.segmentOffset = 0;
|
||
this.receivedBytes = 0;
|
||
this.displayedComplete = false;
|
||
this.startTime = Date.now();
|
||
}
|
||
/**
|
||
* Progress to the next segment. Only call this method when the previous segment
|
||
* is complete.
|
||
*
|
||
* @param segmentSize the length of the next segment
|
||
*/
|
||
nextSegment(segmentSize) {
|
||
this.segmentOffset = this.segmentOffset + this.segmentSize;
|
||
this.segmentIndex = this.segmentIndex + 1;
|
||
this.segmentSize = segmentSize;
|
||
this.receivedBytes = 0;
|
||
core.debug(`Downloading segment at offset ${this.segmentOffset} with length ${this.segmentSize}...`);
|
||
}
|
||
/**
|
||
* Sets the number of bytes received for the current segment.
|
||
*
|
||
* @param receivedBytes the number of bytes received
|
||
*/
|
||
setReceivedBytes(receivedBytes) {
|
||
this.receivedBytes = receivedBytes;
|
||
}
|
||
/**
|
||
* Returns the total number of bytes transferred.
|
||
*/
|
||
getTransferredBytes() {
|
||
return this.segmentOffset + this.receivedBytes;
|
||
}
|
||
/**
|
||
* Returns true if the download is complete.
|
||
*/
|
||
isDone() {
|
||
return this.getTransferredBytes() === this.contentLength;
|
||
}
|
||
/**
|
||
* Prints the current download stats. Once the download completes, this will print one
|
||
* last line and then stop.
|
||
*/
|
||
display() {
|
||
if (this.displayedComplete) {
|
||
return;
|
||
}
|
||
const transferredBytes = this.segmentOffset + this.receivedBytes;
|
||
const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1);
|
||
const elapsedTime = Date.now() - this.startTime;
|
||
const downloadSpeed = (transferredBytes /
|
||
(1024 * 1024) /
|
||
(elapsedTime / 1000)).toFixed(1);
|
||
core.info(`Received ${transferredBytes} of ${this.contentLength} (${percentage}%), ${downloadSpeed} MBs/sec`);
|
||
if (this.isDone()) {
|
||
this.displayedComplete = true;
|
||
}
|
||
}
|
||
/**
|
||
* Returns a function used to handle TransferProgressEvents.
|
||
*/
|
||
onProgress() {
|
||
return (progress) => {
|
||
this.setReceivedBytes(progress.loadedBytes);
|
||
};
|
||
}
|
||
/**
|
||
* Starts the timer that displays the stats.
|
||
*
|
||
* @param delayInMs the delay between each write
|
||
*/
|
||
startDisplayTimer(delayInMs = 1000) {
|
||
const displayCallback = () => {
|
||
this.display();
|
||
if (!this.isDone()) {
|
||
this.timeoutHandle = setTimeout(displayCallback, delayInMs);
|
||
}
|
||
};
|
||
this.timeoutHandle = setTimeout(displayCallback, delayInMs);
|
||
}
|
||
/**
|
||
* Stops the timer that displays the stats. As this typically indicates the download
|
||
* is complete, this will display one last line, unless the last line has already
|
||
* been written.
|
||
*/
|
||
stopDisplayTimer() {
|
||
if (this.timeoutHandle) {
|
||
clearTimeout(this.timeoutHandle);
|
||
this.timeoutHandle = undefined;
|
||
}
|
||
this.display();
|
||
}
|
||
}
|
||
exports.DownloadProgress = DownloadProgress;
|
||
/**
|
||
* Download the cache using the Actions toolkit http-client
|
||
*
|
||
* @param archiveLocation the URL for the cache
|
||
* @param archivePath the local path where the cache is saved
|
||
*/
|
||
function downloadCacheHttpClient(archiveLocation, archivePath) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const writeStream = fs.createWriteStream(archivePath);
|
||
const httpClient = new http_client_1.HttpClient('actions/cache');
|
||
const downloadResponse = yield requestUtils_1.retryHttpClientResponse('downloadCache', () => __awaiter(this, void 0, void 0, function* () { return httpClient.get(archiveLocation); }));
|
||
// Abort download if no traffic received over the socket.
|
||
downloadResponse.message.socket.setTimeout(constants_1.SocketTimeout, () => {
|
||
downloadResponse.message.destroy();
|
||
core.debug(`Aborting download, socket timed out after ${constants_1.SocketTimeout} ms`);
|
||
});
|
||
yield pipeResponseToStream(downloadResponse, writeStream);
|
||
// Validate download size.
|
||
const contentLengthHeader = downloadResponse.message.headers['content-length'];
|
||
if (contentLengthHeader) {
|
||
const expectedLength = parseInt(contentLengthHeader);
|
||
const actualLength = utils.getArchiveFileSizeInBytes(archivePath);
|
||
if (actualLength !== expectedLength) {
|
||
throw new Error(`Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`);
|
||
}
|
||
}
|
||
else {
|
||
core.debug('Unable to validate download, no Content-Length header');
|
||
}
|
||
});
|
||
}
|
||
exports.downloadCacheHttpClient = downloadCacheHttpClient;
|
||
/**
|
||
* Download the cache using the Azure Storage SDK. Only call this method if the
|
||
* URL points to an Azure Storage endpoint.
|
||
*
|
||
* @param archiveLocation the URL for the cache
|
||
* @param archivePath the local path where the cache is saved
|
||
* @param options the download options with the defaults set
|
||
*/
|
||
function downloadCacheStorageSDK(archiveLocation, archivePath, options) {
|
||
var _a;
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const client = new storage_blob_1.BlockBlobClient(archiveLocation, undefined, {
|
||
retryOptions: {
|
||
// Override the timeout used when downloading each 4 MB chunk
|
||
// The default is 2 min / MB, which is way too slow
|
||
tryTimeoutInMs: options.timeoutInMs
|
||
}
|
||
});
|
||
const properties = yield client.getProperties();
|
||
const contentLength = (_a = properties.contentLength) !== null && _a !== void 0 ? _a : -1;
|
||
if (contentLength < 0) {
|
||
// We should never hit this condition, but just in case fall back to downloading the
|
||
// file as one large stream
|
||
core.debug('Unable to determine content length, downloading file with http-client...');
|
||
yield downloadCacheHttpClient(archiveLocation, archivePath);
|
||
}
|
||
else {
|
||
// Use downloadToBuffer for faster downloads, since internally it splits the
|
||
// file into 4 MB chunks which can then be parallelized and retried independently
|
||
//
|
||
// If the file exceeds the buffer maximum length (~1 GB on 32-bit systems and ~2 GB
|
||
// on 64-bit systems), split the download into multiple segments
|
||
// ~2 GB = 2147483647, beyond this, we start getting out of range error. So, capping it accordingly.
|
||
const maxSegmentSize = Math.min(2147483647, buffer.constants.MAX_LENGTH);
|
||
const downloadProgress = new DownloadProgress(contentLength);
|
||
const fd = fs.openSync(archivePath, 'w');
|
||
try {
|
||
downloadProgress.startDisplayTimer();
|
||
const controller = new abort_controller_1.AbortController();
|
||
const abortSignal = controller.signal;
|
||
while (!downloadProgress.isDone()) {
|
||
const segmentStart = downloadProgress.segmentOffset + downloadProgress.segmentSize;
|
||
const segmentSize = Math.min(maxSegmentSize, contentLength - segmentStart);
|
||
downloadProgress.nextSegment(segmentSize);
|
||
const result = yield promiseWithTimeout(options.segmentTimeoutInMs || 3600000, client.downloadToBuffer(segmentStart, segmentSize, {
|
||
abortSignal,
|
||
concurrency: options.downloadConcurrency,
|
||
onProgress: downloadProgress.onProgress()
|
||
}));
|
||
if (result === 'timeout') {
|
||
controller.abort();
|
||
throw new Error('Aborting cache download as the download time exceeded the timeout.');
|
||
}
|
||
else if (Buffer.isBuffer(result)) {
|
||
fs.writeFileSync(fd, result);
|
||
}
|
||
}
|
||
}
|
||
finally {
|
||
downloadProgress.stopDisplayTimer();
|
||
fs.closeSync(fd);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
exports.downloadCacheStorageSDK = downloadCacheStorageSDK;
|
||
const promiseWithTimeout = (timeoutMs, promise) => __awaiter(void 0, void 0, void 0, function* () {
|
||
let timeoutHandle;
|
||
const timeoutPromise = new Promise(resolve => {
|
||
timeoutHandle = setTimeout(() => resolve('timeout'), timeoutMs);
|
||
});
|
||
return Promise.race([promise, timeoutPromise]).then(result => {
|
||
clearTimeout(timeoutHandle);
|
||
return result;
|
||
});
|
||
});
|
||
//# sourceMappingURL=downloadUtils.js.map
|
||
|
||
/***/ }),
|
||
/* 252 */,
|
||
/* 253 */,
|
||
/* 254 */,
|
||
/* 255 */,
|
||
/* 256 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
const usm = __webpack_require__(936);
|
||
|
||
exports.implementation = class URLImpl {
|
||
constructor(constructorArgs) {
|
||
const url = constructorArgs[0];
|
||
const base = constructorArgs[1];
|
||
|
||
let parsedBase = null;
|
||
if (base !== undefined) {
|
||
parsedBase = usm.basicURLParse(base);
|
||
if (parsedBase === "failure") {
|
||
throw new TypeError("Invalid base URL");
|
||
}
|
||
}
|
||
|
||
const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
|
||
if (parsedURL === "failure") {
|
||
throw new TypeError("Invalid URL");
|
||
}
|
||
|
||
this._url = parsedURL;
|
||
|
||
// TODO: query stuff
|
||
}
|
||
|
||
get href() {
|
||
return usm.serializeURL(this._url);
|
||
}
|
||
|
||
set href(v) {
|
||
const parsedURL = usm.basicURLParse(v);
|
||
if (parsedURL === "failure") {
|
||
throw new TypeError("Invalid URL");
|
||
}
|
||
|
||
this._url = parsedURL;
|
||
}
|
||
|
||
get origin() {
|
||
return usm.serializeURLOrigin(this._url);
|
||
}
|
||
|
||
get protocol() {
|
||
return this._url.scheme + ":";
|
||
}
|
||
|
||
set protocol(v) {
|
||
usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" });
|
||
}
|
||
|
||
get username() {
|
||
return this._url.username;
|
||
}
|
||
|
||
set username(v) {
|
||
if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
|
||
return;
|
||
}
|
||
|
||
usm.setTheUsername(this._url, v);
|
||
}
|
||
|
||
get password() {
|
||
return this._url.password;
|
||
}
|
||
|
||
set password(v) {
|
||
if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
|
||
return;
|
||
}
|
||
|
||
usm.setThePassword(this._url, v);
|
||
}
|
||
|
||
get host() {
|
||
const url = this._url;
|
||
|
||
if (url.host === null) {
|
||
return "";
|
||
}
|
||
|
||
if (url.port === null) {
|
||
return usm.serializeHost(url.host);
|
||
}
|
||
|
||
return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port);
|
||
}
|
||
|
||
set host(v) {
|
||
if (this._url.cannotBeABaseURL) {
|
||
return;
|
||
}
|
||
|
||
usm.basicURLParse(v, { url: this._url, stateOverride: "host" });
|
||
}
|
||
|
||
get hostname() {
|
||
if (this._url.host === null) {
|
||
return "";
|
||
}
|
||
|
||
return usm.serializeHost(this._url.host);
|
||
}
|
||
|
||
set hostname(v) {
|
||
if (this._url.cannotBeABaseURL) {
|
||
return;
|
||
}
|
||
|
||
usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" });
|
||
}
|
||
|
||
get port() {
|
||
if (this._url.port === null) {
|
||
return "";
|
||
}
|
||
|
||
return usm.serializeInteger(this._url.port);
|
||
}
|
||
|
||
set port(v) {
|
||
if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
|
||
return;
|
||
}
|
||
|
||
if (v === "") {
|
||
this._url.port = null;
|
||
} else {
|
||
usm.basicURLParse(v, { url: this._url, stateOverride: "port" });
|
||
}
|
||
}
|
||
|
||
get pathname() {
|
||
if (this._url.cannotBeABaseURL) {
|
||
return this._url.path[0];
|
||
}
|
||
|
||
if (this._url.path.length === 0) {
|
||
return "";
|
||
}
|
||
|
||
return "/" + this._url.path.join("/");
|
||
}
|
||
|
||
set pathname(v) {
|
||
if (this._url.cannotBeABaseURL) {
|
||
return;
|
||
}
|
||
|
||
this._url.path = [];
|
||
usm.basicURLParse(v, { url: this._url, stateOverride: "path start" });
|
||
}
|
||
|
||
get search() {
|
||
if (this._url.query === null || this._url.query === "") {
|
||
return "";
|
||
}
|
||
|
||
return "?" + this._url.query;
|
||
}
|
||
|
||
set search(v) {
|
||
// TODO: query stuff
|
||
|
||
const url = this._url;
|
||
|
||
if (v === "") {
|
||
url.query = null;
|
||
return;
|
||
}
|
||
|
||
const input = v[0] === "?" ? v.substring(1) : v;
|
||
url.query = "";
|
||
usm.basicURLParse(input, { url, stateOverride: "query" });
|
||
}
|
||
|
||
get hash() {
|
||
if (this._url.fragment === null || this._url.fragment === "") {
|
||
return "";
|
||
}
|
||
|
||
return "#" + this._url.fragment;
|
||
}
|
||
|
||
set hash(v) {
|
||
if (v === "") {
|
||
this._url.fragment = null;
|
||
return;
|
||
}
|
||
|
||
const input = v[0] === "#" ? v.substring(1) : v;
|
||
this._url.fragment = "";
|
||
usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" });
|
||
}
|
||
|
||
toJSON() {
|
||
return this.href;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 257 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1,
|
||
hasProp = {}.hasOwnProperty;
|
||
|
||
ref1 = __webpack_require__(582), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue;
|
||
|
||
XMLElement = null;
|
||
|
||
XMLCData = null;
|
||
|
||
XMLComment = null;
|
||
|
||
XMLDeclaration = null;
|
||
|
||
XMLDocType = null;
|
||
|
||
XMLRaw = null;
|
||
|
||
XMLText = null;
|
||
|
||
XMLProcessingInstruction = null;
|
||
|
||
XMLDummy = null;
|
||
|
||
NodeType = null;
|
||
|
||
XMLNodeList = null;
|
||
|
||
XMLNamedNodeMap = null;
|
||
|
||
DocumentPosition = null;
|
||
|
||
module.exports = XMLNode = (function() {
|
||
function XMLNode(parent1) {
|
||
this.parent = parent1;
|
||
if (this.parent) {
|
||
this.options = this.parent.options;
|
||
this.stringify = this.parent.stringify;
|
||
}
|
||
this.value = null;
|
||
this.children = [];
|
||
this.baseURI = null;
|
||
if (!XMLElement) {
|
||
XMLElement = __webpack_require__(796);
|
||
XMLCData = __webpack_require__(657);
|
||
XMLComment = __webpack_require__(919);
|
||
XMLDeclaration = __webpack_require__(738);
|
||
XMLDocType = __webpack_require__(735);
|
||
XMLRaw = __webpack_require__(660);
|
||
XMLText = __webpack_require__(708);
|
||
XMLProcessingInstruction = __webpack_require__(491);
|
||
XMLDummy = __webpack_require__(956);
|
||
NodeType = __webpack_require__(683);
|
||
XMLNodeList = __webpack_require__(265);
|
||
XMLNamedNodeMap = __webpack_require__(451);
|
||
DocumentPosition = __webpack_require__(65);
|
||
}
|
||
}
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'nodeName', {
|
||
get: function() {
|
||
return this.name;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'nodeType', {
|
||
get: function() {
|
||
return this.type;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'nodeValue', {
|
||
get: function() {
|
||
return this.value;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'parentNode', {
|
||
get: function() {
|
||
return this.parent;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'childNodes', {
|
||
get: function() {
|
||
if (!this.childNodeList || !this.childNodeList.nodes) {
|
||
this.childNodeList = new XMLNodeList(this.children);
|
||
}
|
||
return this.childNodeList;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'firstChild', {
|
||
get: function() {
|
||
return this.children[0] || null;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'lastChild', {
|
||
get: function() {
|
||
return this.children[this.children.length - 1] || null;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'previousSibling', {
|
||
get: function() {
|
||
var i;
|
||
i = this.parent.children.indexOf(this);
|
||
return this.parent.children[i - 1] || null;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'nextSibling', {
|
||
get: function() {
|
||
var i;
|
||
i = this.parent.children.indexOf(this);
|
||
return this.parent.children[i + 1] || null;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'ownerDocument', {
|
||
get: function() {
|
||
return this.document() || null;
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(XMLNode.prototype, 'textContent', {
|
||
get: function() {
|
||
var child, j, len, ref2, str;
|
||
if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {
|
||
str = '';
|
||
ref2 = this.children;
|
||
for (j = 0, len = ref2.length; j < len; j++) {
|
||
child = ref2[j];
|
||
if (child.textContent) {
|
||
str += child.textContent;
|
||
}
|
||
}
|
||
return str;
|
||
} else {
|
||
return null;
|
||
}
|
||
},
|
||
set: function(value) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
}
|
||
});
|
||
|
||
XMLNode.prototype.setParent = function(parent) {
|
||
var child, j, len, ref2, results;
|
||
this.parent = parent;
|
||
if (parent) {
|
||
this.options = parent.options;
|
||
this.stringify = parent.stringify;
|
||
}
|
||
ref2 = this.children;
|
||
results = [];
|
||
for (j = 0, len = ref2.length; j < len; j++) {
|
||
child = ref2[j];
|
||
results.push(child.setParent(this));
|
||
}
|
||
return results;
|
||
};
|
||
|
||
XMLNode.prototype.element = function(name, attributes, text) {
|
||
var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val;
|
||
lastChild = null;
|
||
if (attributes === null && (text == null)) {
|
||
ref2 = [{}, null], attributes = ref2[0], text = ref2[1];
|
||
}
|
||
if (attributes == null) {
|
||
attributes = {};
|
||
}
|
||
attributes = getValue(attributes);
|
||
if (!isObject(attributes)) {
|
||
ref3 = [attributes, text], text = ref3[0], attributes = ref3[1];
|
||
}
|
||
if (name != null) {
|
||
name = getValue(name);
|
||
}
|
||
if (Array.isArray(name)) {
|
||
for (j = 0, len = name.length; j < len; j++) {
|
||
item = name[j];
|
||
lastChild = this.element(item);
|
||
}
|
||
} else if (isFunction(name)) {
|
||
lastChild = this.element(name.apply());
|
||
} else if (isObject(name)) {
|
||
for (key in name) {
|
||
if (!hasProp.call(name, key)) continue;
|
||
val = name[key];
|
||
if (isFunction(val)) {
|
||
val = val.apply();
|
||
}
|
||
if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
|
||
lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
|
||
} else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) {
|
||
lastChild = this.dummy();
|
||
} else if (isObject(val) && isEmpty(val)) {
|
||
lastChild = this.element(key);
|
||
} else if (!this.options.keepNullNodes && (val == null)) {
|
||
lastChild = this.dummy();
|
||
} else if (!this.options.separateArrayItems && Array.isArray(val)) {
|
||
for (k = 0, len1 = val.length; k < len1; k++) {
|
||
item = val[k];
|
||
childNode = {};
|
||
childNode[key] = item;
|
||
lastChild = this.element(childNode);
|
||
}
|
||
} else if (isObject(val)) {
|
||
if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {
|
||
lastChild = this.element(val);
|
||
} else {
|
||
lastChild = this.element(key);
|
||
lastChild.element(val);
|
||
}
|
||
} else {
|
||
lastChild = this.element(key, val);
|
||
}
|
||
}
|
||
} else if (!this.options.keepNullNodes && text === null) {
|
||
lastChild = this.dummy();
|
||
} else {
|
||
if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
|
||
lastChild = this.text(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
|
||
lastChild = this.cdata(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
|
||
lastChild = this.comment(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
|
||
lastChild = this.raw(text);
|
||
} else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
|
||
lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
|
||
} else {
|
||
lastChild = this.node(name, attributes, text);
|
||
}
|
||
}
|
||
if (lastChild == null) {
|
||
throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
|
||
}
|
||
return lastChild;
|
||
};
|
||
|
||
XMLNode.prototype.insertBefore = function(name, attributes, text) {
|
||
var child, i, newChild, refChild, removed;
|
||
if (name != null ? name.type : void 0) {
|
||
newChild = name;
|
||
refChild = attributes;
|
||
newChild.setParent(this);
|
||
if (refChild) {
|
||
i = children.indexOf(refChild);
|
||
removed = children.splice(i);
|
||
children.push(newChild);
|
||
Array.prototype.push.apply(children, removed);
|
||
} else {
|
||
children.push(newChild);
|
||
}
|
||
return newChild;
|
||
} else {
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i);
|
||
child = this.parent.element(name, attributes, text);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return child;
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.insertAfter = function(name, attributes, text) {
|
||
var child, i, removed;
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i + 1);
|
||
child = this.parent.element(name, attributes, text);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.remove = function() {
|
||
var i, ref2;
|
||
if (this.isRoot) {
|
||
throw new Error("Cannot remove the root element. " + this.debugInfo());
|
||
}
|
||
i = this.parent.children.indexOf(this);
|
||
[].splice.apply(this.parent.children, [i, i - i + 1].concat(ref2 = [])), ref2;
|
||
return this.parent;
|
||
};
|
||
|
||
XMLNode.prototype.node = function(name, attributes, text) {
|
||
var child, ref2;
|
||
if (name != null) {
|
||
name = getValue(name);
|
||
}
|
||
attributes || (attributes = {});
|
||
attributes = getValue(attributes);
|
||
if (!isObject(attributes)) {
|
||
ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];
|
||
}
|
||
child = new XMLElement(this, name, attributes);
|
||
if (text != null) {
|
||
child.text(text);
|
||
}
|
||
this.children.push(child);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.text = function(value) {
|
||
var child;
|
||
if (isObject(value)) {
|
||
this.element(value);
|
||
}
|
||
child = new XMLText(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.cdata = function(value) {
|
||
var child;
|
||
child = new XMLCData(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.comment = function(value) {
|
||
var child;
|
||
child = new XMLComment(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.commentBefore = function(value) {
|
||
var child, i, removed;
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i);
|
||
child = this.parent.comment(value);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.commentAfter = function(value) {
|
||
var child, i, removed;
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i + 1);
|
||
child = this.parent.comment(value);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.raw = function(value) {
|
||
var child;
|
||
child = new XMLRaw(this, value);
|
||
this.children.push(child);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.dummy = function() {
|
||
var child;
|
||
child = new XMLDummy(this);
|
||
return child;
|
||
};
|
||
|
||
XMLNode.prototype.instruction = function(target, value) {
|
||
var insTarget, insValue, instruction, j, len;
|
||
if (target != null) {
|
||
target = getValue(target);
|
||
}
|
||
if (value != null) {
|
||
value = getValue(value);
|
||
}
|
||
if (Array.isArray(target)) {
|
||
for (j = 0, len = target.length; j < len; j++) {
|
||
insTarget = target[j];
|
||
this.instruction(insTarget);
|
||
}
|
||
} else if (isObject(target)) {
|
||
for (insTarget in target) {
|
||
if (!hasProp.call(target, insTarget)) continue;
|
||
insValue = target[insTarget];
|
||
this.instruction(insTarget, insValue);
|
||
}
|
||
} else {
|
||
if (isFunction(value)) {
|
||
value = value.apply();
|
||
}
|
||
instruction = new XMLProcessingInstruction(this, target, value);
|
||
this.children.push(instruction);
|
||
}
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.instructionBefore = function(target, value) {
|
||
var child, i, removed;
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i);
|
||
child = this.parent.instruction(target, value);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.instructionAfter = function(target, value) {
|
||
var child, i, removed;
|
||
i = this.parent.children.indexOf(this);
|
||
removed = this.parent.children.splice(i + 1);
|
||
child = this.parent.instruction(target, value);
|
||
Array.prototype.push.apply(this.parent.children, removed);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.declaration = function(version, encoding, standalone) {
|
||
var doc, xmldec;
|
||
doc = this.document();
|
||
xmldec = new XMLDeclaration(doc, version, encoding, standalone);
|
||
if (doc.children.length === 0) {
|
||
doc.children.unshift(xmldec);
|
||
} else if (doc.children[0].type === NodeType.Declaration) {
|
||
doc.children[0] = xmldec;
|
||
} else {
|
||
doc.children.unshift(xmldec);
|
||
}
|
||
return doc.root() || doc;
|
||
};
|
||
|
||
XMLNode.prototype.dtd = function(pubID, sysID) {
|
||
var child, doc, doctype, i, j, k, len, len1, ref2, ref3;
|
||
doc = this.document();
|
||
doctype = new XMLDocType(doc, pubID, sysID);
|
||
ref2 = doc.children;
|
||
for (i = j = 0, len = ref2.length; j < len; i = ++j) {
|
||
child = ref2[i];
|
||
if (child.type === NodeType.DocType) {
|
||
doc.children[i] = doctype;
|
||
return doctype;
|
||
}
|
||
}
|
||
ref3 = doc.children;
|
||
for (i = k = 0, len1 = ref3.length; k < len1; i = ++k) {
|
||
child = ref3[i];
|
||
if (child.isRoot) {
|
||
doc.children.splice(i, 0, doctype);
|
||
return doctype;
|
||
}
|
||
}
|
||
doc.children.push(doctype);
|
||
return doctype;
|
||
};
|
||
|
||
XMLNode.prototype.up = function() {
|
||
if (this.isRoot) {
|
||
throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
|
||
}
|
||
return this.parent;
|
||
};
|
||
|
||
XMLNode.prototype.root = function() {
|
||
var node;
|
||
node = this;
|
||
while (node) {
|
||
if (node.type === NodeType.Document) {
|
||
return node.rootObject;
|
||
} else if (node.isRoot) {
|
||
return node;
|
||
} else {
|
||
node = node.parent;
|
||
}
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.document = function() {
|
||
var node;
|
||
node = this;
|
||
while (node) {
|
||
if (node.type === NodeType.Document) {
|
||
return node;
|
||
} else {
|
||
node = node.parent;
|
||
}
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.end = function(options) {
|
||
return this.document().end(options);
|
||
};
|
||
|
||
XMLNode.prototype.prev = function() {
|
||
var i;
|
||
i = this.parent.children.indexOf(this);
|
||
if (i < 1) {
|
||
throw new Error("Already at the first node. " + this.debugInfo());
|
||
}
|
||
return this.parent.children[i - 1];
|
||
};
|
||
|
||
XMLNode.prototype.next = function() {
|
||
var i;
|
||
i = this.parent.children.indexOf(this);
|
||
if (i === -1 || i === this.parent.children.length - 1) {
|
||
throw new Error("Already at the last node. " + this.debugInfo());
|
||
}
|
||
return this.parent.children[i + 1];
|
||
};
|
||
|
||
XMLNode.prototype.importDocument = function(doc) {
|
||
var clonedRoot;
|
||
clonedRoot = doc.root().clone();
|
||
clonedRoot.parent = this;
|
||
clonedRoot.isRoot = false;
|
||
this.children.push(clonedRoot);
|
||
return this;
|
||
};
|
||
|
||
XMLNode.prototype.debugInfo = function(name) {
|
||
var ref2, ref3;
|
||
name = name || this.name;
|
||
if ((name == null) && !((ref2 = this.parent) != null ? ref2.name : void 0)) {
|
||
return "";
|
||
} else if (name == null) {
|
||
return "parent: <" + this.parent.name + ">";
|
||
} else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) {
|
||
return "node: <" + name + ">";
|
||
} else {
|
||
return "node: <" + name + ">, parent: <" + this.parent.name + ">";
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.ele = function(name, attributes, text) {
|
||
return this.element(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.nod = function(name, attributes, text) {
|
||
return this.node(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.txt = function(value) {
|
||
return this.text(value);
|
||
};
|
||
|
||
XMLNode.prototype.dat = function(value) {
|
||
return this.cdata(value);
|
||
};
|
||
|
||
XMLNode.prototype.com = function(value) {
|
||
return this.comment(value);
|
||
};
|
||
|
||
XMLNode.prototype.ins = function(target, value) {
|
||
return this.instruction(target, value);
|
||
};
|
||
|
||
XMLNode.prototype.doc = function() {
|
||
return this.document();
|
||
};
|
||
|
||
XMLNode.prototype.dec = function(version, encoding, standalone) {
|
||
return this.declaration(version, encoding, standalone);
|
||
};
|
||
|
||
XMLNode.prototype.e = function(name, attributes, text) {
|
||
return this.element(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.n = function(name, attributes, text) {
|
||
return this.node(name, attributes, text);
|
||
};
|
||
|
||
XMLNode.prototype.t = function(value) {
|
||
return this.text(value);
|
||
};
|
||
|
||
XMLNode.prototype.d = function(value) {
|
||
return this.cdata(value);
|
||
};
|
||
|
||
XMLNode.prototype.c = function(value) {
|
||
return this.comment(value);
|
||
};
|
||
|
||
XMLNode.prototype.r = function(value) {
|
||
return this.raw(value);
|
||
};
|
||
|
||
XMLNode.prototype.i = function(target, value) {
|
||
return this.instruction(target, value);
|
||
};
|
||
|
||
XMLNode.prototype.u = function() {
|
||
return this.up();
|
||
};
|
||
|
||
XMLNode.prototype.importXMLBuilder = function(doc) {
|
||
return this.importDocument(doc);
|
||
};
|
||
|
||
XMLNode.prototype.replaceChild = function(newChild, oldChild) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.removeChild = function(oldChild) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.appendChild = function(newChild) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.hasChildNodes = function() {
|
||
return this.children.length !== 0;
|
||
};
|
||
|
||
XMLNode.prototype.cloneNode = function(deep) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.normalize = function() {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.isSupported = function(feature, version) {
|
||
return true;
|
||
};
|
||
|
||
XMLNode.prototype.hasAttributes = function() {
|
||
return this.attribs.length !== 0;
|
||
};
|
||
|
||
XMLNode.prototype.compareDocumentPosition = function(other) {
|
||
var ref, res;
|
||
ref = this;
|
||
if (ref === other) {
|
||
return 0;
|
||
} else if (this.document() !== other.document()) {
|
||
res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;
|
||
if (Math.random() < 0.5) {
|
||
res |= DocumentPosition.Preceding;
|
||
} else {
|
||
res |= DocumentPosition.Following;
|
||
}
|
||
return res;
|
||
} else if (ref.isAncestor(other)) {
|
||
return DocumentPosition.Contains | DocumentPosition.Preceding;
|
||
} else if (ref.isDescendant(other)) {
|
||
return DocumentPosition.Contains | DocumentPosition.Following;
|
||
} else if (ref.isPreceding(other)) {
|
||
return DocumentPosition.Preceding;
|
||
} else {
|
||
return DocumentPosition.Following;
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.isSameNode = function(other) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.lookupPrefix = function(namespaceURI) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.isDefaultNamespace = function(namespaceURI) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.lookupNamespaceURI = function(prefix) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.isEqualNode = function(node) {
|
||
var i, j, ref2;
|
||
if (node.nodeType !== this.nodeType) {
|
||
return false;
|
||
}
|
||
if (node.children.length !== this.children.length) {
|
||
return false;
|
||
}
|
||
for (i = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i = 0 <= ref2 ? ++j : --j) {
|
||
if (!this.children[i].isEqualNode(node.children[i])) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
};
|
||
|
||
XMLNode.prototype.getFeature = function(feature, version) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.setUserData = function(key, data, handler) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.getUserData = function(key) {
|
||
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
||
};
|
||
|
||
XMLNode.prototype.contains = function(other) {
|
||
if (!other) {
|
||
return false;
|
||
}
|
||
return other === this || this.isDescendant(other);
|
||
};
|
||
|
||
XMLNode.prototype.isDescendant = function(node) {
|
||
var child, isDescendantChild, j, len, ref2;
|
||
ref2 = this.children;
|
||
for (j = 0, len = ref2.length; j < len; j++) {
|
||
child = ref2[j];
|
||
if (node === child) {
|
||
return true;
|
||
}
|
||
isDescendantChild = child.isDescendant(node);
|
||
if (isDescendantChild) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
|
||
XMLNode.prototype.isAncestor = function(node) {
|
||
return node.isDescendant(this);
|
||
};
|
||
|
||
XMLNode.prototype.isPreceding = function(node) {
|
||
var nodePos, thisPos;
|
||
nodePos = this.treePosition(node);
|
||
thisPos = this.treePosition(this);
|
||
if (nodePos === -1 || thisPos === -1) {
|
||
return false;
|
||
} else {
|
||
return nodePos < thisPos;
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.isFollowing = function(node) {
|
||
var nodePos, thisPos;
|
||
nodePos = this.treePosition(node);
|
||
thisPos = this.treePosition(this);
|
||
if (nodePos === -1 || thisPos === -1) {
|
||
return false;
|
||
} else {
|
||
return nodePos > thisPos;
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.treePosition = function(node) {
|
||
var found, pos;
|
||
pos = 0;
|
||
found = false;
|
||
this.foreachTreeNode(this.document(), function(childNode) {
|
||
pos++;
|
||
if (!found && childNode === node) {
|
||
return found = true;
|
||
}
|
||
});
|
||
if (found) {
|
||
return pos;
|
||
} else {
|
||
return -1;
|
||
}
|
||
};
|
||
|
||
XMLNode.prototype.foreachTreeNode = function(node, func) {
|
||
var child, j, len, ref2, res;
|
||
node || (node = this.document());
|
||
ref2 = node.children;
|
||
for (j = 0, len = ref2.length; j < len; j++) {
|
||
child = ref2[j];
|
||
if (res = func(child)) {
|
||
return res;
|
||
} else {
|
||
res = this.foreachTreeNode(child, func);
|
||
if (res) {
|
||
return res;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
return XMLNode;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 258 */,
|
||
/* 259 */,
|
||
/* 260 */,
|
||
/* 261 */,
|
||
/* 262 */,
|
||
/* 263 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
var api = __webpack_require__(440);
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
(function (SpanKind) {
|
||
/** Default value. Indicates that the span is used internally. */
|
||
SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
|
||
/**
|
||
* Indicates that the span covers server-side handling of an RPC or other
|
||
* remote request.
|
||
*/
|
||
SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
|
||
/**
|
||
* Indicates that the span covers the client-side wrapper around an RPC or
|
||
* other remote request.
|
||
*/
|
||
SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
|
||
/**
|
||
* Indicates that the span describes producer sending a message to a
|
||
* broker. Unlike client and server, there is no direct critical path latency
|
||
* relationship between producer and consumer spans.
|
||
*/
|
||
SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
|
||
/**
|
||
* Indicates that the span describes consumer receiving a message from a
|
||
* broker. Unlike client and server, there is no direct critical path latency
|
||
* relationship between producer and consumer spans.
|
||
*/
|
||
SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
|
||
})(exports.SpanKind || (exports.SpanKind = {}));
|
||
/**
|
||
* Return the span if one exists
|
||
*
|
||
* @param context - context to get span from
|
||
*/
|
||
function getSpan(context) {
|
||
return api.trace.getSpan(context);
|
||
}
|
||
/**
|
||
* Set the span on a context
|
||
*
|
||
* @param context - context to use as parent
|
||
* @param span - span to set active
|
||
*/
|
||
function setSpan(context, span) {
|
||
return api.trace.setSpan(context, span);
|
||
}
|
||
/**
|
||
* Wrap span context in a NoopSpan and set as span in a new
|
||
* context
|
||
*
|
||
* @param context - context to set active span on
|
||
* @param spanContext - span context to be wrapped
|
||
*/
|
||
function setSpanContext(context, spanContext) {
|
||
return api.trace.setSpanContext(context, spanContext);
|
||
}
|
||
/**
|
||
* Get the span context of the span if it exists.
|
||
*
|
||
* @param context - context to get values from
|
||
*/
|
||
function getSpanContext(context) {
|
||
return api.trace.getSpanContext(context);
|
||
}
|
||
/**
|
||
* Returns true of the given {@link SpanContext} is valid.
|
||
* A valid {@link SpanContext} is one which has a valid trace ID and span ID as per the spec.
|
||
*
|
||
* @param context - the {@link SpanContext} to validate.
|
||
*
|
||
* @returns true if the {@link SpanContext} is valid, false otherwise.
|
||
*/
|
||
function isSpanContextValid(context) {
|
||
return api.trace.isSpanContextValid(context);
|
||
}
|
||
function getTracer(name, version) {
|
||
return api.trace.getTracer(name || "azure/core-tracing", version);
|
||
}
|
||
/** Entrypoint for context API */
|
||
const context = api.context;
|
||
(function (SpanStatusCode) {
|
||
/**
|
||
* The default status.
|
||
*/
|
||
SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
|
||
/**
|
||
* The operation has been validated by an Application developer or
|
||
* Operator to have completed successfully.
|
||
*/
|
||
SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
|
||
/**
|
||
* The operation contains an error.
|
||
*/
|
||
SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
|
||
})(exports.SpanStatusCode || (exports.SpanStatusCode = {}));
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
function isTracingDisabled() {
|
||
var _a;
|
||
if (typeof process === "undefined") {
|
||
// not supported in browser for now without polyfills
|
||
return false;
|
||
}
|
||
const azureTracingDisabledValue = (_a = process.env.AZURE_TRACING_DISABLED) === null || _a === void 0 ? void 0 : _a.toLowerCase();
|
||
if (azureTracingDisabledValue === "false" || azureTracingDisabledValue === "0") {
|
||
return false;
|
||
}
|
||
return Boolean(azureTracingDisabledValue);
|
||
}
|
||
/**
|
||
* Creates a function that can be used to create spans using the global tracer.
|
||
*
|
||
* Usage:
|
||
*
|
||
* ```typescript
|
||
* // once
|
||
* const createSpan = createSpanFunction({ packagePrefix: "Azure.Data.AppConfiguration", namespace: "Microsoft.AppConfiguration" });
|
||
*
|
||
* // in each operation
|
||
* const span = createSpan("deleteConfigurationSetting", operationOptions);
|
||
* // code...
|
||
* span.end();
|
||
* ```
|
||
*
|
||
* @hidden
|
||
* @param args - allows configuration of the prefix for each span as well as the az.namespace field.
|
||
*/
|
||
function createSpanFunction(args) {
|
||
return function (operationName, operationOptions) {
|
||
const tracer = getTracer();
|
||
const tracingOptions = (operationOptions === null || operationOptions === void 0 ? void 0 : operationOptions.tracingOptions) || {};
|
||
const spanOptions = Object.assign({ kind: exports.SpanKind.INTERNAL }, tracingOptions.spanOptions);
|
||
const spanName = args.packagePrefix ? `${args.packagePrefix}.${operationName}` : operationName;
|
||
let span;
|
||
if (isTracingDisabled()) {
|
||
span = api.trace.wrapSpanContext(api.INVALID_SPAN_CONTEXT);
|
||
}
|
||
else {
|
||
span = tracer.startSpan(spanName, spanOptions, tracingOptions.tracingContext);
|
||
}
|
||
if (args.namespace) {
|
||
span.setAttribute("az.namespace", args.namespace);
|
||
}
|
||
let newSpanOptions = tracingOptions.spanOptions || {};
|
||
if (span.isRecording() && args.namespace) {
|
||
newSpanOptions = Object.assign(Object.assign({}, tracingOptions.spanOptions), { attributes: Object.assign(Object.assign({}, spanOptions.attributes), { "az.namespace": args.namespace }) });
|
||
}
|
||
const newTracingOptions = Object.assign(Object.assign({}, tracingOptions), { spanOptions: newSpanOptions, tracingContext: setSpan(tracingOptions.tracingContext || context.active(), span) });
|
||
const newOperationOptions = Object.assign(Object.assign({}, operationOptions), { tracingOptions: newTracingOptions });
|
||
return {
|
||
span,
|
||
updatedOptions: newOperationOptions
|
||
};
|
||
};
|
||
}
|
||
|
||
// Copyright (c) Microsoft Corporation.
|
||
// Licensed under the MIT license.
|
||
const VERSION = "00";
|
||
/**
|
||
* Generates a `SpanContext` given a `traceparent` header value.
|
||
* @param traceParent - Serialized span context data as a `traceparent` header value.
|
||
* @returns The `SpanContext` generated from the `traceparent` value.
|
||
*/
|
||
function extractSpanContextFromTraceParentHeader(traceParentHeader) {
|
||
const parts = traceParentHeader.split("-");
|
||
if (parts.length !== 4) {
|
||
return;
|
||
}
|
||
const [version, traceId, spanId, traceOptions] = parts;
|
||
if (version !== VERSION) {
|
||
return;
|
||
}
|
||
const traceFlags = parseInt(traceOptions, 16);
|
||
const spanContext = {
|
||
spanId,
|
||
traceId,
|
||
traceFlags
|
||
};
|
||
return spanContext;
|
||
}
|
||
/**
|
||
* Generates a `traceparent` value given a span context.
|
||
* @param spanContext - Contains context for a specific span.
|
||
* @returns The `spanContext` represented as a `traceparent` value.
|
||
*/
|
||
function getTraceParentHeader(spanContext) {
|
||
const missingFields = [];
|
||
if (!spanContext.traceId) {
|
||
missingFields.push("traceId");
|
||
}
|
||
if (!spanContext.spanId) {
|
||
missingFields.push("spanId");
|
||
}
|
||
if (missingFields.length) {
|
||
return;
|
||
}
|
||
const flags = spanContext.traceFlags || 0 /* NONE */;
|
||
const hexFlags = flags.toString(16);
|
||
const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;
|
||
// https://www.w3.org/TR/trace-context/#traceparent-header-field-values
|
||
return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;
|
||
}
|
||
|
||
exports.context = context;
|
||
exports.createSpanFunction = createSpanFunction;
|
||
exports.extractSpanContextFromTraceParentHeader = extractSpanContextFromTraceParentHeader;
|
||
exports.getSpan = getSpan;
|
||
exports.getSpanContext = getSpanContext;
|
||
exports.getTraceParentHeader = getTraceParentHeader;
|
||
exports.getTracer = getTracer;
|
||
exports.isSpanContextValid = isSpanContextValid;
|
||
exports.setSpan = setSpan;
|
||
exports.setSpanContext = setSpanContext;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
|
||
/***/ }),
|
||
/* 264 */,
|
||
/* 265 */
|
||
/***/ (function(module) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
var XMLNodeList;
|
||
|
||
module.exports = XMLNodeList = (function() {
|
||
function XMLNodeList(nodes) {
|
||
this.nodes = nodes;
|
||
}
|
||
|
||
Object.defineProperty(XMLNodeList.prototype, 'length', {
|
||
get: function() {
|
||
return this.nodes.length || 0;
|
||
}
|
||
});
|
||
|
||
XMLNodeList.prototype.clone = function() {
|
||
return this.nodes = null;
|
||
};
|
||
|
||
XMLNodeList.prototype.item = function(index) {
|
||
return this.nodes[index] || null;
|
||
};
|
||
|
||
return XMLNodeList;
|
||
|
||
})();
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 266 */,
|
||
/* 267 */,
|
||
/* 268 */,
|
||
/* 269 */,
|
||
/* 270 */,
|
||
/* 271 */,
|
||
/* 272 */,
|
||
/* 273 */,
|
||
/* 274 */,
|
||
/* 275 */,
|
||
/* 276 */,
|
||
/* 277 */,
|
||
/* 278 */,
|
||
/* 279 */,
|
||
/* 280 */
|
||
/***/ (function(module, exports) {
|
||
|
||
exports = module.exports = SemVer
|
||
|
||
var debug
|
||
/* istanbul ignore next */
|
||
if (typeof process === 'object' &&
|
||
process.env &&
|
||
process.env.NODE_DEBUG &&
|
||
/\bsemver\b/i.test(process.env.NODE_DEBUG)) {
|
||
debug = function () {
|
||
var args = Array.prototype.slice.call(arguments, 0)
|
||
args.unshift('SEMVER')
|
||
console.log.apply(console, args)
|
||
}
|
||
} else {
|
||
debug = function () {}
|
||
}
|
||
|
||
// Note: this is the semver.org version of the spec that it implements
|
||
// Not necessarily the package version of this code.
|
||
exports.SEMVER_SPEC_VERSION = '2.0.0'
|
||
|
||
var MAX_LENGTH = 256
|
||
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
|
||
/* istanbul ignore next */ 9007199254740991
|
||
|
||
// Max safe segment length for coercion.
|
||
var MAX_SAFE_COMPONENT_LENGTH = 16
|
||
|
||
// The actual regexps go on exports.re
|
||
var re = exports.re = []
|
||
var src = exports.src = []
|
||
var t = exports.tokens = {}
|
||
var R = 0
|
||
|
||
function tok (n) {
|
||
t[n] = R++
|
||
}
|
||
|
||
// The following Regular Expressions can be used for tokenizing,
|
||
// validating, and parsing SemVer version strings.
|
||
|
||
// ## Numeric Identifier
|
||
// A single `0`, or a non-zero digit followed by zero or more digits.
|
||
|
||
tok('NUMERICIDENTIFIER')
|
||
src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'
|
||
tok('NUMERICIDENTIFIERLOOSE')
|
||
src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'
|
||
|
||
// ## Non-numeric Identifier
|
||
// Zero or more digits, followed by a letter or hyphen, and then zero or
|
||
// more letters, digits, or hyphens.
|
||
|
||
tok('NONNUMERICIDENTIFIER')
|
||
src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
|
||
|
||
// ## Main Version
|
||
// Three dot-separated numeric identifiers.
|
||
|
||
tok('MAINVERSION')
|
||
src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
|
||
'(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
|
||
'(' + src[t.NUMERICIDENTIFIER] + ')'
|
||
|
||
tok('MAINVERSIONLOOSE')
|
||
src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
|
||
'(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
|
||
'(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'
|
||
|
||
// ## Pre-release Version Identifier
|
||
// A numeric identifier, or a non-numeric identifier.
|
||
|
||
tok('PRERELEASEIDENTIFIER')
|
||
src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
|
||
'|' + src[t.NONNUMERICIDENTIFIER] + ')'
|
||
|
||
tok('PRERELEASEIDENTIFIERLOOSE')
|
||
src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
|
||
'|' + src[t.NONNUMERICIDENTIFIER] + ')'
|
||
|
||
// ## Pre-release Version
|
||
// Hyphen, followed by one or more dot-separated pre-release version
|
||
// identifiers.
|
||
|
||
tok('PRERELEASE')
|
||
src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
|
||
'(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))'
|
||
|
||
tok('PRERELEASELOOSE')
|
||
src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
|
||
'(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'
|
||
|
||
// ## Build Metadata Identifier
|
||
// Any combination of digits, letters, or hyphens.
|
||
|
||
tok('BUILDIDENTIFIER')
|
||
src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
|
||
|
||
// ## Build Metadata
|
||
// Plus sign, followed by one or more period-separated build metadata
|
||
// identifiers.
|
||
|
||
tok('BUILD')
|
||
src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] +
|
||
'(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))'
|
||
|
||
// ## Full Version String
|
||
// A main version, followed optionally by a pre-release version and
|
||
// build metadata.
|
||
|
||
// Note that the only major, minor, patch, and pre-release sections of
|
||
// the version string are capturing groups. The build metadata is not a
|
||
// capturing group, because it should not ever be used in version
|
||
// comparison.
|
||
|
||
tok('FULL')
|
||
tok('FULLPLAIN')
|
||
src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
|
||
src[t.PRERELEASE] + '?' +
|
||
src[t.BUILD] + '?'
|
||
|
||
src[t.FULL] = '^' + src[t.FULLPLAIN] + '$'
|
||
|
||
// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
|
||
// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
|
||
// common in the npm registry.
|
||
tok('LOOSEPLAIN')
|
||
src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
|
||
src[t.PRERELEASELOOSE] + '?' +
|
||
src[t.BUILD] + '?'
|
||
|
||
tok('LOOSE')
|
||
src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$'
|
||
|
||
tok('GTLT')
|
||
src[t.GTLT] = '((?:<|>)?=?)'
|
||
|
||
// Something like "2.*" or "1.2.x".
|
||
// Note that "x.x" is a valid xRange identifer, meaning "any version"
|
||
// Only the first item is strictly required.
|
||
tok('XRANGEIDENTIFIERLOOSE')
|
||
src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
|
||
tok('XRANGEIDENTIFIER')
|
||
src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*'
|
||
|
||
tok('XRANGEPLAIN')
|
||
src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
|
||
'(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
|
||
'(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
|
||
'(?:' + src[t.PRERELEASE] + ')?' +
|
||
src[t.BUILD] + '?' +
|
||
')?)?'
|
||
|
||
tok('XRANGEPLAINLOOSE')
|
||
src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
|
||
'(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
|
||
'(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
|
||
'(?:' + src[t.PRERELEASELOOSE] + ')?' +
|
||
src[t.BUILD] + '?' +
|
||
')?)?'
|
||
|
||
tok('XRANGE')
|
||
src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$'
|
||
tok('XRANGELOOSE')
|
||
src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'
|
||
|
||
// Coercion.
|
||
// Extract anything that could conceivably be a part of a valid semver
|
||
tok('COERCE')
|
||
src[t.COERCE] = '(^|[^\\d])' +
|
||
'(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
|
||
'(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
|
||
'(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
|
||
'(?:$|[^\\d])'
|
||
tok('COERCERTL')
|
||
re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')
|
||
|
||
// Tilde ranges.
|
||
// Meaning is "reasonably at or greater than"
|
||
tok('LONETILDE')
|
||
src[t.LONETILDE] = '(?:~>?)'
|
||
|
||
tok('TILDETRIM')
|
||
src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'
|
||
re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')
|
||
var tildeTrimReplace = '$1~'
|
||
|
||
tok('TILDE')
|
||
src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$'
|
||
tok('TILDELOOSE')
|
||
src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'
|
||
|
||
// Caret ranges.
|
||
// Meaning is "at least and backwards compatible with"
|
||
tok('LONECARET')
|
||
src[t.LONECARET] = '(?:\\^)'
|
||
|
||
tok('CARETTRIM')
|
||
src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'
|
||
re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')
|
||
var caretTrimReplace = '$1^'
|
||
|
||
tok('CARET')
|
||
src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$'
|
||
tok('CARETLOOSE')
|
||
src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'
|
||
|
||
// A simple gt/lt/eq thing, or just "" to indicate "any version"
|
||
tok('COMPARATORLOOSE')
|
||
src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$'
|
||
tok('COMPARATOR')
|
||
src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$'
|
||
|
||
// An expression to strip any whitespace between the gtlt and the thing
|
||
// it modifies, so that `> 1.2.3` ==> `>1.2.3`
|
||
tok('COMPARATORTRIM')
|
||
src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
|
||
'\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'
|
||
|
||
// this one has to use the /g flag
|
||
re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')
|
||
var comparatorTrimReplace = '$1$2$3'
|
||
|
||
// Something like `1.2.3 - 1.2.4`
|
||
// Note that these all use the loose form, because they'll be
|
||
// checked against either the strict or loose comparator form
|
||
// later.
|
||
tok('HYPHENRANGE')
|
||
src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
|
||
'\\s+-\\s+' +
|
||
'(' + src[t.XRANGEPLAIN] + ')' +
|
||
'\\s*$'
|
||
|
||
tok('HYPHENRANGELOOSE')
|
||
src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
|
||
'\\s+-\\s+' +
|
||
'(' + src[t.XRANGEPLAINLOOSE] + ')' +
|
||
'\\s*$'
|
||
|
||
// Star ranges basically just allow anything at all.
|
||
tok('STAR')
|
||
src[t.STAR] = '(<|>)?=?\\s*\\*'
|
||
|
||
// Compile to actual regexp objects.
|
||
// All are flag-free, unless they were created above with a flag.
|
||
for (var i = 0; i < R; i++) {
|
||
debug(i, src[i])
|
||
if (!re[i]) {
|
||
re[i] = new RegExp(src[i])
|
||
}
|
||
}
|
||
|
||
exports.parse = parse
|
||
function parse (version, options) {
|
||
if (!options || typeof options !== 'object') {
|
||
options = {
|
||
loose: !!options,
|
||
includePrerelease: false
|
||
}
|
||
}
|
||
|
||
if (version instanceof SemVer) {
|
||
return version
|
||
}
|
||
|
||
if (typeof version !== 'string') {
|
||
return null
|
||
}
|
||
|
||
if (version.length > MAX_LENGTH) {
|
||
return null
|
||
}
|
||
|
||
var r = options.loose ? re[t.LOOSE] : re[t.FULL]
|
||
if (!r.test(version)) {
|
||
return null
|
||
}
|
||
|
||
try {
|
||
return new SemVer(version, options)
|
||
} catch (er) {
|
||
return null
|
||
}
|
||
}
|
||
|
||
exports.valid = valid
|
||
function valid (version, options) {
|
||
var v = parse(version, options)
|
||
return v ? v.version : null
|
||
}
|
||
|
||
exports.clean = clean
|
||
function clean (version, options) {
|
||
var s = parse(version.trim().replace(/^[=v]+/, ''), options)
|
||
return s ? s.version : null
|
||
}
|
||
|
||
exports.SemVer = SemVer
|
||
|
||
function SemVer (version, options) {
|
||
if (!options || typeof options !== 'object') {
|
||
options = {
|
||
loose: !!options,
|
||
includePrerelease: false
|
||
}
|
||
}
|
||
if (version instanceof SemVer) {
|
||
if (version.loose === options.loose) {
|
||
return version
|
||
} else {
|
||
version = version.version
|
||
}
|
||
} else if (typeof version !== 'string') {
|
||
throw new TypeError('Invalid Version: ' + version)
|
||
}
|
||
|
||
if (version.length > MAX_LENGTH) {
|
||
throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
|
||
}
|
||
|
||
if (!(this instanceof SemVer)) {
|
||
return new SemVer(version, options)
|
||
}
|
||
|
||
debug('SemVer', version, options)
|
||
this.options = options
|
||
this.loose = !!options.loose
|
||
|
||
var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
|
||
|
||
if (!m) {
|
||
throw new TypeError('Invalid Version: ' + version)
|
||
}
|
||
|
||
this.raw = version
|
||
|
||
// these are actually numbers
|
||
this.major = +m[1]
|
||
this.minor = +m[2]
|
||
this.patch = +m[3]
|
||
|
||
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
||
throw new TypeError('Invalid major version')
|
||
}
|
||
|
||
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
||
throw new TypeError('Invalid minor version')
|
||
}
|
||
|
||
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
||
throw new TypeError('Invalid patch version')
|
||
}
|
||
|
||
// numberify any prerelease numeric ids
|
||
if (!m[4]) {
|
||
this.prerelease = []
|
||
} else {
|
||
this.prerelease = m[4].split('.').map(function (id) {
|
||
if (/^[0-9]+$/.test(id)) {
|
||
var num = +id
|
||
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
||
return num
|
||
}
|
||
}
|
||
return id
|
||
})
|
||
}
|
||
|
||
this.build = m[5] ? m[5].split('.') : []
|
||
this.format()
|
||
}
|
||
|
||
SemVer.prototype.format = function () {
|
||
this.version = this.major + '.' + this.minor + '.' + this.patch
|
||
if (this.prerelease.length) {
|
||
this.version += '-' + this.prerelease.join('.')
|
||
}
|
||
return this.version
|
||
}
|
||
|
||
SemVer.prototype.toString = function () {
|
||
return this.version
|
||
}
|
||
|
||
SemVer.prototype.compare = function (other) {
|
||
debug('SemVer.compare', this.version, this.options, other)
|
||
if (!(other instanceof SemVer)) {
|
||
other = new SemVer(other, this.options)
|
||
}
|
||
|
||
return this.compareMain(other) || this.comparePre(other)
|
||
}
|
||
|
||
SemVer.prototype.compareMain = function (other) {
|
||
if (!(other instanceof SemVer)) {
|
||
other = new SemVer(other, this.options)
|
||
}
|
||
|
||
return compareIdentifiers(this.major, other.major) ||
|
||
compareIdentifiers(this.minor, other.minor) ||
|
||
compareIdentifiers(this.patch, other.patch)
|
||
}
|
||
|
||
SemVer.prototype.comparePre = function (other) {
|
||
if (!(other instanceof SemVer)) {
|
||
other = new SemVer(other, this.options)
|
||
}
|
||
|
||
// NOT having a prerelease is > having one
|
||
if (this.prerelease.length && !other.prerelease.length) {
|
||
return -1
|
||
} else if (!this.prerelease.length && other.prerelease.length) {
|
||
return 1
|
||
} else if (!this.prerelease.length && !other.prerelease.length) {
|
||
return 0
|
||
}
|
||
|
||
var i = 0
|
||
do {
|
||
var a = this.prerelease[i]
|
||
var b = other.prerelease[i]
|
||
debug('prerelease compare', i, a, b)
|
||
if (a === undefined && b === undefined) {
|
||
return 0
|
||
} else if (b === undefined) {
|
||
return 1
|
||
} else if (a === undefined) {
|
||
return -1
|
||
} else if (a === b) {
|
||
continue
|
||
} else {
|
||
return compareIdentifiers(a, b)
|
||
}
|
||
} while (++i)
|
||
}
|
||
|
||
SemVer.prototype.compareBuild = function (other) {
|
||
if (!(other instanceof SemVer)) {
|
||
other = new SemVer(other, this.options)
|
||
}
|
||
|
||
var i = 0
|
||
do {
|
||
var a = this.build[i]
|
||
var b = other.build[i]
|
||
debug('prerelease compare', i, a, b)
|
||
if (a === undefined && b === undefined) {
|
||
return 0
|
||
} else if (b === undefined) {
|
||
return 1
|
||
} else if (a === undefined) {
|
||
return -1
|
||
} else if (a === b) {
|
||
continue
|
||
} else {
|
||
return compareIdentifiers(a, b)
|
||
}
|
||
} while (++i)
|
||
}
|
||
|
||
// preminor will bump the version up to the next minor release, and immediately
|
||
// down to pre-release. premajor and prepatch work the same way.
|
||
SemVer.prototype.inc = function (release, identifier) {
|
||
switch (release) {
|
||
case 'premajor':
|
||
this.prerelease.length = 0
|
||
this.patch = 0
|
||
this.minor = 0
|
||
this.major++
|
||
this.inc('pre', identifier)
|
||
break
|
||
case 'preminor':
|
||
this.prerelease.length = 0
|
||
this.patch = 0
|
||
this.minor++
|
||
this.inc('pre', identifier)
|
||
break
|
||
case 'prepatch':
|
||
// If this is already a prerelease, it will bump to the next version
|
||
// drop any prereleases that might already exist, since they are not
|
||
// relevant at this point.
|
||
this.prerelease.length = 0
|
||
this.inc('patch', identifier)
|
||
this.inc('pre', identifier)
|
||
break
|
||
// If the input is a non-prerelease version, this acts the same as
|
||
// prepatch.
|
||
case 'prerelease':
|
||
if (this.prerelease.length === 0) {
|
||
this.inc('patch', identifier)
|
||
}
|
||
this.inc('pre', identifier)
|
||
break
|
||
|
||
case 'major':
|
||
// If this is a pre-major version, bump up to the same major version.
|
||
// Otherwise increment major.
|
||
// 1.0.0-5 bumps to 1.0.0
|
||
// 1.1.0 bumps to 2.0.0
|
||
if (this.minor !== 0 ||
|
||
this.patch !== 0 ||
|
||
this.prerelease.length === 0) {
|
||
this.major++
|
||
}
|
||
this.minor = 0
|
||
this.patch = 0
|
||
this.prerelease = []
|
||
break
|
||
case 'minor':
|
||
// If this is a pre-minor version, bump up to the same minor version.
|
||
// Otherwise increment minor.
|
||
// 1.2.0-5 bumps to 1.2.0
|
||
// 1.2.1 bumps to 1.3.0
|
||
if (this.patch !== 0 || this.prerelease.length === 0) {
|
||
this.minor++
|
||
}
|
||
this.patch = 0
|
||
this.prerelease = []
|
||
break
|
||
case 'patch':
|
||
// If this is not a pre-release version, it will increment the patch.
|
||
// If it is a pre-release it will bump up to the same patch version.
|
||
// 1.2.0-5 patches to 1.2.0
|
||
// 1.2.0 patches to 1.2.1
|
||
if (this.prerelease.length === 0) {
|
||
this.patch++
|
||
}
|
||
this.prerelease = []
|
||
break
|
||
// This probably shouldn't be used publicly.
|
||
// 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
|
||
case 'pre':
|
||
if (this.prerelease.length === 0) {
|
||
this.prerelease = [0]
|
||
} else {
|
||
var i = this.prerelease.length
|
||
while (--i >= 0) {
|
||
if (typeof this.prerelease[i] === 'number') {
|
||
this.prerelease[i]++
|
||
i = -2
|
||
}
|
||
}
|
||
if (i === -1) {
|
||
// didn't increment anything
|
||
this.prerelease.push(0)
|
||
}
|
||
}
|
||
if (identifier) {
|
||
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
|
||
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
|
||
if (this.prerelease[0] === identifier) {
|
||
if (isNaN(this.prerelease[1])) {
|
||
this.prerelease = [identifier, 0]
|
||
}
|
||
} else {
|
||
this.prerelease = [identifier, 0]
|
||
}
|
||
}
|
||
break
|
||
|
||
default:
|
||
throw new Error('invalid increment argument: ' + release)
|
||
}
|
||
this.format()
|
||
this.raw = this.version
|
||
return this
|
||
}
|
||
|
||
exports.inc = inc
|
||
function inc (version, release, loose, identifier) {
|
||
if (typeof (loose) === 'string') {
|
||
identifier = loose
|
||
loose = undefined
|
||
}
|
||
|
||
try {
|
||
return new SemVer(version, loose).inc(release, identifier).version
|
||
} catch (er) {
|
||
return null
|
||
}
|
||
}
|
||
|
||
exports.diff = diff
|
||
function diff (version1, version2) {
|
||
if (eq(version1, version2)) {
|
||
return null
|
||
} else {
|
||
var v1 = parse(version1)
|
||
var v2 = parse(version2)
|
||
var prefix = ''
|
||
if (v1.prerelease.length || v2.prerelease.length) {
|
||
prefix = 'pre'
|
||
var defaultResult = 'prerelease'
|
||
}
|
||
for (var key in v1) {
|
||
if (key === 'major' || key === 'minor' || key === 'patch') {
|
||
if (v1[key] !== v2[key]) {
|
||
return prefix + key
|
||
}
|
||
}
|
||
}
|
||
return defaultResult // may be undefined
|
||
}
|
||
}
|
||
|
||
exports.compareIdentifiers = compareIdentifiers
|
||
|
||
var numeric = /^[0-9]+$/
|
||
function compareIdentifiers (a, b) {
|
||
var anum = numeric.test(a)
|
||
var bnum = numeric.test(b)
|
||
|
||
if (anum && bnum) {
|
||
a = +a
|
||
b = +b
|
||
}
|
||
|
||
return a === b ? 0
|
||
: (anum && !bnum) ? -1
|
||
: (bnum && !anum) ? 1
|
||
: a < b ? -1
|
||
: 1
|
||
}
|
||
|
||
exports.rcompareIdentifiers = rcompareIdentifiers
|
||
function rcompareIdentifiers (a, b) {
|
||
return compareIdentifiers(b, a)
|
||
}
|
||
|
||
exports.major = major
|
||
function major (a, loose) {
|
||
return new SemVer(a, loose).major
|
||
}
|
||
|
||
exports.minor = minor
|
||
function minor (a, loose) {
|
||
return new SemVer(a, loose).minor
|
||
}
|
||
|
||
exports.patch = patch
|
||
function patch (a, loose) {
|
||
return new SemVer(a, loose).patch
|
||
}
|
||
|
||
exports.compare = compare
|
||
function compare (a, b, loose) {
|
||
return new SemVer(a, loose).compare(new SemVer(b, loose))
|
||
}
|
||
|
||
exports.compareLoose = compareLoose
|
||
function compareLoose (a, b) {
|
||
return compare(a, b, true)
|
||
}
|
||
|
||
exports.compareBuild = compareBuild
|
||
function compareBuild (a, b, loose) {
|
||
var versionA = new SemVer(a, loose)
|
||
var versionB = new SemVer(b, loose)
|
||
return versionA.compare(versionB) || versionA.compareBuild(versionB)
|
||
}
|
||
|
||
exports.rcompare = rcompare
|
||
function rcompare (a, b, loose) {
|
||
return compare(b, a, loose)
|
||
}
|
||
|
||
exports.sort = sort
|
||
function sort (list, loose) {
|
||
return list.sort(function (a, b) {
|
||
return exports.compareBuild(a, b, loose)
|
||
})
|
||
}
|
||
|
||
exports.rsort = rsort
|
||
function rsort (list, loose) {
|
||
return list.sort(function (a, b) {
|
||
return exports.compareBuild(b, a, loose)
|
||
})
|
||
}
|
||
|
||
exports.gt = gt
|
||
function gt (a, b, loose) {
|
||
return compare(a, b, loose) > 0
|
||
}
|
||
|
||
exports.lt = lt
|
||
function lt (a, b, loose) {
|
||
return compare(a, b, loose) < 0
|
||
}
|
||
|
||
exports.eq = eq
|
||
function eq (a, b, loose) {
|
||
return compare(a, b, loose) === 0
|
||
}
|
||
|
||
exports.neq = neq
|
||
function neq (a, b, loose) {
|
||
return compare(a, b, loose) !== 0
|
||
}
|
||
|
||
exports.gte = gte
|
||
function gte (a, b, loose) {
|
||
return compare(a, b, loose) >= 0
|
||
}
|
||
|
||
exports.lte = lte
|
||
function lte (a, b, loose) {
|
||
return compare(a, b, loose) <= 0
|
||
}
|
||
|
||
exports.cmp = cmp
|
||
function cmp (a, op, b, loose) {
|
||
switch (op) {
|
||
case '===':
|
||
if (typeof a === 'object')
|
||
a = a.version
|
||
if (typeof b === 'object')
|
||
b = b.version
|
||
return a === b
|
||
|
||
case '!==':
|
||
if (typeof a === 'object')
|
||
a = a.version
|
||
if (typeof b === 'object')
|
||
b = b.version
|
||
return a !== b
|
||
|
||
case '':
|
||
case '=':
|
||
case '==':
|
||
return eq(a, b, loose)
|
||
|
||
case '!=':
|
||
return neq(a, b, loose)
|
||
|
||
case '>':
|
||
return gt(a, b, loose)
|
||
|
||
case '>=':
|
||
return gte(a, b, loose)
|
||
|
||
case '<':
|
||
return lt(a, b, loose)
|
||
|
||
case '<=':
|
||
return lte(a, b, loose)
|
||
|
||
default:
|
||
throw new TypeError('Invalid operator: ' + op)
|
||
}
|
||
}
|
||
|
||
exports.Comparator = Comparator
|
||
function Comparator (comp, options) {
|
||
if (!options || typeof options !== 'object') {
|
||
options = {
|
||
loose: !!options,
|
||
includePrerelease: false
|
||
}
|
||
}
|
||
|
||
if (comp instanceof Comparator) {
|
||
if (comp.loose === !!options.loose) {
|
||
return comp
|
||
} else {
|
||
comp = comp.value
|
||
}
|
||
}
|
||
|
||
if (!(this instanceof Comparator)) {
|
||
return new Comparator(comp, options)
|
||
}
|
||
|
||
debug('comparator', comp, options)
|
||
this.options = options
|
||
this.loose = !!options.loose
|
||
this.parse(comp)
|
||
|
||
if (this.semver === ANY) {
|
||
this.value = ''
|
||
} else {
|
||
this.value = this.operator + this.semver.version
|
||
}
|
||
|
||
debug('comp', this)
|
||
}
|
||
|
||
var ANY = {}
|
||
Comparator.prototype.parse = function (comp) {
|
||
var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
|
||
var m = comp.match(r)
|
||
|
||
if (!m) {
|
||
throw new TypeError('Invalid comparator: ' + comp)
|
||
}
|
||
|
||
this.operator = m[1] !== undefined ? m[1] : ''
|
||
if (this.operator === '=') {
|
||
this.operator = ''
|
||
}
|
||
|
||
// if it literally is just '>' or '' then allow anything.
|
||
if (!m[2]) {
|
||
this.semver = ANY
|
||
} else {
|
||
this.semver = new SemVer(m[2], this.options.loose)
|
||
}
|
||
}
|
||
|
||
Comparator.prototype.toString = function () {
|
||
return this.value
|
||
}
|
||
|
||
Comparator.prototype.test = function (version) {
|
||
debug('Comparator.test', version, this.options.loose)
|
||
|
||
if (this.semver === ANY || version === ANY) {
|
||
return true
|
||
}
|
||
|
||
if (typeof version === 'string') {
|
||
try {
|
||
version = new SemVer(version, this.options)
|
||
} catch (er) {
|
||
return false
|
||
}
|
||
}
|
||
|
||
return cmp(version, this.operator, this.semver, this.options)
|
||
}
|
||
|
||
Comparator.prototype.intersects = function (comp, options) {
|
||
if (!(comp instanceof Comparator)) {
|
||
throw new TypeError('a Comparator is required')
|
||
}
|
||
|
||
if (!options || typeof options !== 'object') {
|
||
options = {
|
||
loose: !!options,
|
||
includePrerelease: false
|
||
}
|
||
}
|
||
|
||
var rangeTmp
|
||
|
||
if (this.operator === '') {
|
||
if (this.value === '') {
|
||
return true
|
||
}
|
||
rangeTmp = new Range(comp.value, options)
|
||
return satisfies(this.value, rangeTmp, options)
|
||
} else if (comp.operator === '') {
|
||
if (comp.value === '') {
|
||
return true
|
||
}
|
||
rangeTmp = new Range(this.value, options)
|
||
return satisfies(comp.semver, rangeTmp, options)
|
||
}
|
||
|
||
var sameDirectionIncreasing =
|
||
(this.operator === '>=' || this.operator === '>') &&
|
||
(comp.operator === '>=' || comp.operator === '>')
|
||
var sameDirectionDecreasing =
|
||
(this.operator === '<=' || this.operator === '<') &&
|
||
(comp.operator === '<=' || comp.operator === '<')
|
||
var sameSemVer = this.semver.version === comp.semver.version
|
||
var differentDirectionsInclusive =
|
||
(this.operator === '>=' || this.operator === '<=') &&
|
||
(comp.operator === '>=' || comp.operator === '<=')
|
||
var oppositeDirectionsLessThan =
|
||
cmp(this.semver, '<', comp.semver, options) &&
|
||
((this.operator === '>=' || this.operator === '>') &&
|
||
(comp.operator === '<=' || comp.operator === '<'))
|
||
var oppositeDirectionsGreaterThan =
|
||
cmp(this.semver, '>', comp.semver, options) &&
|
||
((this.operator === '<=' || this.operator === '<') &&
|
||
(comp.operator === '>=' || comp.operator === '>'))
|
||
|
||
return sameDirectionIncreasing || sameDirectionDecreasing ||
|
||
(sameSemVer && differentDirectionsInclusive) ||
|
||
oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
|
||
}
|
||
|
||
exports.Range = Range
|
||
function Range (range, options) {
|
||
if (!options || typeof options !== 'object') {
|
||
options = {
|
||
loose: !!options,
|
||
includePrerelease: false
|
||
}
|
||
}
|
||
|
||
if (range instanceof Range) {
|
||
if (range.loose === !!options.loose &&
|
||
range.includePrerelease === !!options.includePrerelease) {
|
||
return range
|
||
} else {
|
||
return new Range(range.raw, options)
|
||
}
|
||
}
|
||
|
||
if (range instanceof Comparator) {
|
||
return new Range(range.value, options)
|
||
}
|
||
|
||
if (!(this instanceof Range)) {
|
||
return new Range(range, options)
|
||
}
|
||
|
||
this.options = options
|
||
this.loose = !!options.loose
|
||
this.includePrerelease = !!options.includePrerelease
|
||
|
||
// First, split based on boolean or ||
|
||
this.raw = range
|
||
this.set = range.split(/\s*\|\|\s*/).map(function (range) {
|
||
return this.parseRange(range.trim())
|
||
}, this).filter(function (c) {
|
||
// throw out any that are not relevant for whatever reason
|
||
return c.length
|
||
})
|
||
|
||
if (!this.set.length) {
|
||
throw new TypeError('Invalid SemVer Range: ' + range)
|
||
}
|
||
|
||
this.format()
|
||
}
|
||
|
||
Range.prototype.format = function () {
|
||
this.range = this.set.map(function (comps) {
|
||
return comps.join(' ').trim()
|
||
}).join('||').trim()
|
||
return this.range
|
||
}
|
||
|
||
Range.prototype.toString = function () {
|
||
return this.range
|
||
}
|
||
|
||
Range.prototype.parseRange = function (range) {
|
||
var loose = this.options.loose
|
||
range = range.trim()
|
||
// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
|
||
var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
|
||
range = range.replace(hr, hyphenReplace)
|
||
debug('hyphen replace', range)
|
||
// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
|
||
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
|
||
debug('comparator trim', range, re[t.COMPARATORTRIM])
|
||
|
||
// `~ 1.2.3` => `~1.2.3`
|
||
range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
|
||
|
||
// `^ 1.2.3` => `^1.2.3`
|
||
range = range.replace(re[t.CARETTRIM], caretTrimReplace)
|
||
|
||
// normalize spaces
|
||
range = range.split(/\s+/).join(' ')
|
||
|
||
// At this point, the range is completely trimmed and
|
||
// ready to be split into comparators.
|
||
|
||
var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
|
||
var set = range.split(' ').map(function (comp) {
|
||
return parseComparator(comp, this.options)
|
||
}, this).join(' ').split(/\s+/)
|
||
if (this.options.loose) {
|
||
// in loose mode, throw out any that are not valid comparators
|
||
set = set.filter(function (comp) {
|
||
return !!comp.match(compRe)
|
||
})
|
||
}
|
||
set = set.map(function (comp) {
|
||
return new Comparator(comp, this.options)
|
||
}, this)
|
||
|
||
return set
|
||
}
|
||
|
||
Range.prototype.intersects = function (range, options) {
|
||
if (!(range instanceof Range)) {
|
||
throw new TypeError('a Range is required')
|
||
}
|
||
|
||
return this.set.some(function (thisComparators) {
|
||
return (
|
||
isSatisfiable(thisComparators, options) &&
|
||
range.set.some(function (rangeComparators) {
|
||
return (
|
||
isSatisfiable(rangeComparators, options) &&
|
||
thisComparators.every(function (thisComparator) {
|
||
return rangeComparators.every(function (rangeComparator) {
|
||
return thisComparator.intersects(rangeComparator, options)
|
||
})
|
||
})
|
||
)
|
||
})
|
||
)
|
||
})
|
||
}
|
||
|
||
// take a set of comparators and determine whether there
|
||
// exists a version which can satisfy it
|
||
function isSatisfiable (comparators, options) {
|
||
var result = true
|
||
var remainingComparators = comparators.slice()
|
||
var testComparator = remainingComparators.pop()
|
||
|
||
while (result && remainingComparators.length) {
|
||
result = remainingComparators.every(function (otherComparator) {
|
||
return testComparator.intersects(otherComparator, options)
|
||
})
|
||
|
||
testComparator = remainingComparators.pop()
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// Mostly just for testing and legacy API reasons
|
||
exports.toComparators = toComparators
|
||
function toComparators (range, options) {
|
||
return new Range(range, options).set.map(function (comp) {
|
||
return comp.map(function (c) {
|
||
return c.value
|
||
}).join(' ').trim().split(' ')
|
||
})
|
||
}
|
||
|
||
// comprised of xranges, tildes, stars, and gtlt's at this point.
|
||
// already replaced the hyphen ranges
|
||
// turn into a set of JUST comparators.
|
||
function parseComparator (comp, options) {
|
||
debug('comp', comp, options)
|
||
comp = replaceCarets(comp, options)
|
||
debug('caret', comp)
|
||
comp = replaceTildes(comp, options)
|
||
debug('tildes', comp)
|
||
comp = replaceXRanges(comp, options)
|
||
debug('xrange', comp)
|
||
comp = replaceStars(comp, options)
|
||
debug('stars', comp)
|
||
return comp
|
||
}
|
||
|
||
function isX (id) {
|
||
return !id || id.toLowerCase() === 'x' || id === '*'
|
||
}
|
||
|
||
// ~, ~> --> * (any, kinda silly)
|
||
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
|
||
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
|
||
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
|
||
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
|
||
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
|
||
function replaceTildes (comp, options) {
|
||
return comp.trim().split(/\s+/).map(function (comp) {
|
||
return replaceTilde(comp, options)
|
||
}).join(' ')
|
||
}
|
||
|
||
function replaceTilde (comp, options) {
|
||
var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
|
||
return comp.replace(r, function (_, M, m, p, pr) {
|
||
debug('tilde', comp, _, M, m, p, pr)
|
||
var ret
|
||
|
||
if (isX(M)) {
|
||
ret = ''
|
||
} else if (isX(m)) {
|
||
ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
|
||
} else if (isX(p)) {
|
||
// ~1.2 == >=1.2.0 <1.3.0
|
||
ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
|
||
} else if (pr) {
|
||
debug('replaceTilde pr', pr)
|
||
ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
|
||
' <' + M + '.' + (+m + 1) + '.0'
|
||
} else {
|
||
// ~1.2.3 == >=1.2.3 <1.3.0
|
||
ret = '>=' + M + '.' + m + '.' + p +
|
||
' <' + M + '.' + (+m + 1) + '.0'
|
||
}
|
||
|
||
debug('tilde return', ret)
|
||
return ret
|
||
})
|
||
}
|
||
|
||
// ^ --> * (any, kinda silly)
|
||
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
|
||
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
|
||
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
|
||
// ^1.2.3 --> >=1.2.3 <2.0.0
|
||
// ^1.2.0 --> >=1.2.0 <2.0.0
|
||
function replaceCarets (comp, options) {
|
||
return comp.trim().split(/\s+/).map(function (comp) {
|
||
return replaceCaret(comp, options)
|
||
}).join(' ')
|
||
}
|
||
|
||
function replaceCaret (comp, options) {
|
||
debug('caret', comp, options)
|
||
var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
|
||
return comp.replace(r, function (_, M, m, p, pr) {
|
||
debug('caret', comp, _, M, m, p, pr)
|
||
var ret
|
||
|
||
if (isX(M)) {
|
||
ret = ''
|
||
} else if (isX(m)) {
|
||
ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
|
||
} else if (isX(p)) {
|
||
if (M === '0') {
|
||
ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
|
||
} else {
|
||
ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
|
||
}
|
||
} else if (pr) {
|
||
debug('replaceCaret pr', pr)
|
||
if (M === '0') {
|
||
if (m === '0') {
|
||
ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
|
||
' <' + M + '.' + m + '.' + (+p + 1)
|
||
} else {
|
||
ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
|
||
' <' + M + '.' + (+m + 1) + '.0'
|
||
}
|
||
} else {
|
||
ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
|
||
' <' + (+M + 1) + '.0.0'
|
||
}
|
||
} else {
|
||
debug('no pr')
|
||
if (M === '0') {
|
||
if (m === '0') {
|
||
ret = '>=' + M + '.' + m + '.' + p +
|
||
' <' + M + '.' + m + '.' + (+p + 1)
|
||
} else {
|
||
ret = '>=' + M + '.' + m + '.' + p +
|
||
' <' + M + '.' + (+m + 1) + '.0'
|
||
}
|
||
} else {
|
||
ret = '>=' + M + '.' + m + '.' + p +
|
||
' <' + (+M + 1) + '.0.0'
|
||
}
|
||
}
|
||
|
||
debug('caret return', ret)
|
||
return ret
|
||
})
|
||
}
|
||
|
||
function replaceXRanges (comp, options) {
|
||
debug('replaceXRanges', comp, options)
|
||
return comp.split(/\s+/).map(function (comp) {
|
||
return replaceXRange(comp, options)
|
||
}).join(' ')
|
||
}
|
||
|
||
function replaceXRange (comp, options) {
|
||
comp = comp.trim()
|
||
var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
|
||
return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
|
||
debug('xRange', comp, ret, gtlt, M, m, p, pr)
|
||
var xM = isX(M)
|
||
var xm = xM || isX(m)
|
||
var xp = xm || isX(p)
|
||
var anyX = xp
|
||
|
||
if (gtlt === '=' && anyX) {
|
||
gtlt = ''
|
||
}
|
||
|
||
// if we're including prereleases in the match, then we need
|
||
// to fix this to -0, the lowest possible prerelease value
|
||
pr = options.includePrerelease ? '-0' : ''
|
||
|
||
if (xM) {
|
||
if (gtlt === '>' || gtlt === '<') {
|
||
// nothing is allowed
|
||
ret = '<0.0.0-0'
|
||
} else {
|
||
// nothing is forbidden
|
||
ret = '*'
|
||
}
|
||
} else if (gtlt && anyX) {
|
||
// we know patch is an x, because we have any x at all.
|
||
// replace X with 0
|
||
if (xm) {
|
||
m = 0
|
||
}
|
||
p = 0
|
||
|
||
if (gtlt === '>') {
|
||
// >1 => >=2.0.0
|
||
// >1.2 => >=1.3.0
|
||
// >1.2.3 => >= 1.2.4
|
||
gtlt = '>='
|
||
if (xm) {
|
||
M = +M + 1
|
||
m = 0
|
||
p = 0
|
||
} else {
|
||
m = +m + 1
|
||
p = 0
|
||
}
|
||
} else if (gtlt === '<=') {
|
||
// <=0.7.x is actually <0.8.0, since any 0.7.x should
|
||
// pass. Similarly, <=7.x is actually <8.0.0, etc.
|
||
gtlt = '<'
|
||
if (xm) {
|
||
M = +M + 1
|
||
} else {
|
||
m = +m + 1
|
||
}
|
||
}
|
||
|
||
ret = gtlt + M + '.' + m + '.' + p + pr
|
||
} else if (xm) {
|
||
ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr
|
||
} else if (xp) {
|
||
ret = '>=' + M + '.' + m + '.0' + pr +
|
||
' <' + M + '.' + (+m + 1) + '.0' + pr
|
||
}
|
||
|
||
debug('xRange return', ret)
|
||
|
||
return ret
|
||
})
|
||
}
|
||
|
||
// Because * is AND-ed with everything else in the comparator,
|
||
// and '' means "any version", just remove the *s entirely.
|
||
function replaceStars (comp, options) {
|
||
debug('replaceStars', comp, options)
|
||
// Looseness is ignored here. star is always as loose as it gets!
|
||
return comp.trim().replace(re[t.STAR], '')
|
||
}
|
||
|
||
// This function is passed to string.replace(re[t.HYPHENRANGE])
|
||
// M, m, patch, prerelease, build
|
||
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
|
||
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
|
||
// 1.2 - 3.4 => >=1.2.0 <3.5.0
|
||
function hyphenReplace ($0,
|
||
from, fM, fm, fp, fpr, fb,
|
||
to, tM, tm, tp, tpr, tb) {
|
||
if (isX(fM)) {
|
||
from = ''
|
||
} else if (isX(fm)) {
|
||
from = '>=' + fM + '.0.0'
|
||
} else if (isX(fp)) {
|
||
from = '>=' + fM + '.' + fm + '.0'
|
||
} else {
|
||
from = '>=' + from
|
||
}
|
||
|
||
if (isX(tM)) {
|
||
to = ''
|
||
} else if (isX(tm)) {
|
||
to = '<' + (+tM + 1) + '.0.0'
|
||
} else if (isX(tp)) {
|
||
to = '<' + tM + '.' + (+tm + 1) + '.0'
|
||
} else if (tpr) {
|
||
to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
|
||
} else {
|
||
to = '<=' + to
|
||
}
|
||
|
||
return (from + ' ' + to).trim()
|
||
}
|
||
|
||
// if ANY of the sets match ALL of its comparators, then pass
|
||
Range.prototype.test = function (version) {
|
||
if (!version) {
|
||
return false
|
||
}
|
||
|
||
if (typeof version === 'string') {
|
||
try {
|
||
version = new SemVer(version, this.options)
|
||
} catch (er) {
|
||
return false
|
||
}
|
||
}
|
||
|
||
for (var i = 0; i < this.set.length; i++) {
|
||
if (testSet(this.set[i], version, this.options)) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
function testSet (set, version, options) {
|
||
for (var i = 0; i < set.length; i++) {
|
||
if (!set[i].test(version)) {
|
||
return false
|
||
}
|
||
}
|
||
|
||
if (version.prerelease.length && !options.includePrerelease) {
|
||
// Find the set of versions that are allowed to have prereleases
|
||
// For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
|
||
// That should allow `1.2.3-pr.2` to pass.
|
||
// However, `1.2.4-alpha.notready` should NOT be allowed,
|
||
// even though it's within the range set by the comparators.
|
||
for (i = 0; i < set.length; i++) {
|
||
debug(set[i].semver)
|
||
if (set[i].semver === ANY) {
|
||
continue
|
||
}
|
||
|
||
if (set[i].semver.prerelease.length > 0) {
|
||
var allowed = set[i].semver
|
||
if (allowed.major === version.major &&
|
||
allowed.minor === version.minor &&
|
||
allowed.patch === version.patch) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
|
||
// Version has a -pre, but it's not one of the ones we like.
|
||
return false
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
exports.satisfies = satisfies
|
||
function satisfies (version, range, options) {
|
||
try {
|
||
range = new Range(range, options)
|
||
} catch (er) {
|
||
return false
|
||
}
|
||
return range.test(version)
|
||
}
|
||
|
||
exports.maxSatisfying = maxSatisfying
|
||
function maxSatisfying (versions, range, options) {
|
||
var max = null
|
||
var maxSV = null
|
||
try {
|
||
var rangeObj = new Range(range, options)
|
||
} catch (er) {
|
||
return null
|
||
}
|
||
versions.forEach(function (v) {
|
||
if (rangeObj.test(v)) {
|
||
// satisfies(v, range, options)
|
||
if (!max || maxSV.compare(v) === -1) {
|
||
// compare(max, v, true)
|
||
max = v
|
||
maxSV = new SemVer(max, options)
|
||
}
|
||
}
|
||
})
|
||
return max
|
||
}
|
||
|
||
exports.minSatisfying = minSatisfying
|
||
function minSatisfying (versions, range, options) {
|
||
var min = null
|
||
var minSV = null
|
||
try {
|
||
var rangeObj = new Range(range, options)
|
||
} catch (er) {
|
||
return null
|
||
}
|
||
versions.forEach(function (v) {
|
||
if (rangeObj.test(v)) {
|
||
// satisfies(v, range, options)
|
||
if (!min || minSV.compare(v) === 1) {
|
||
// compare(min, v, true)
|
||
min = v
|
||
minSV = new SemVer(min, options)
|
||
}
|
||
}
|
||
})
|
||
return min
|
||
}
|
||
|
||
exports.minVersion = minVersion
|
||
function minVersion (range, loose) {
|
||
range = new Range(range, loose)
|
||
|
||
var minver = new SemVer('0.0.0')
|
||
if (range.test(minver)) {
|
||
return minver
|
||
}
|
||
|
||
minver = new SemVer('0.0.0-0')
|
||
if (range.test(minver)) {
|
||
return minver
|
||
}
|
||
|
||
minver = null
|
||
for (var i = 0; i < range.set.length; ++i) {
|
||
var comparators = range.set[i]
|
||
|
||
comparators.forEach(function (comparator) {
|
||
// Clone to avoid manipulating the comparator's semver object.
|
||
var compver = new SemVer(comparator.semver.version)
|
||
switch (comparator.operator) {
|
||
case '>':
|
||
if (compver.prerelease.length === 0) {
|
||
compver.patch++
|
||
} else {
|
||
compver.prerelease.push(0)
|
||
}
|
||
compver.raw = compver.format()
|
||
/* fallthrough */
|
||
case '':
|
||
case '>=':
|
||
if (!minver || gt(minver, compver)) {
|
||
minver = compver
|
||
}
|
||
break
|
||
case '<':
|
||
case '<=':
|
||
/* Ignore maximum versions */
|
||
break
|
||
/* istanbul ignore next */
|
||
default:
|
||
throw new Error('Unexpected operation: ' + comparator.operator)
|
||
}
|
||
})
|
||
}
|
||
|
||
if (minver && range.test(minver)) {
|
||
return minver
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
exports.validRange = validRange
|
||
function validRange (range, options) {
|
||
try {
|
||
// Return '*' instead of '' so that truthiness works.
|
||
// This will throw if it's invalid anyway
|
||
return new Range(range, options).range || '*'
|
||
} catch (er) {
|
||
return null
|
||
}
|
||
}
|
||
|
||
// Determine if version is less than all the versions possible in the range
|
||
exports.ltr = ltr
|
||
function ltr (version, range, options) {
|
||
return outside(version, range, '<', options)
|
||
}
|
||
|
||
// Determine if version is greater than all the versions possible in the range.
|
||
exports.gtr = gtr
|
||
function gtr (version, range, options) {
|
||
return outside(version, range, '>', options)
|
||
}
|
||
|
||
exports.outside = outside
|
||
function outside (version, range, hilo, options) {
|
||
version = new SemVer(version, options)
|
||
range = new Range(range, options)
|
||
|
||
var gtfn, ltefn, ltfn, comp, ecomp
|
||
switch (hilo) {
|
||
case '>':
|
||
gtfn = gt
|
||
ltefn = lte
|
||
ltfn = lt
|
||
comp = '>'
|
||
ecomp = '>='
|
||
break
|
||
case '<':
|
||
gtfn = lt
|
||
ltefn = gte
|
||
ltfn = gt
|
||
comp = '<'
|
||
ecomp = '<='
|
||
break
|
||
default:
|
||
throw new TypeError('Must provide a hilo val of "<" or ">"')
|
||
}
|
||
|
||
// If it satisifes the range it is not outside
|
||
if (satisfies(version, range, options)) {
|
||
return false
|
||
}
|
||
|
||
// From now on, variable terms are as if we're in "gtr" mode.
|
||
// but note that everything is flipped for the "ltr" function.
|
||
|
||
for (var i = 0; i < range.set.length; ++i) {
|
||
var comparators = range.set[i]
|
||
|
||
var high = null
|
||
var low = null
|
||
|
||
comparators.forEach(function (comparator) {
|
||
if (comparator.semver === ANY) {
|
||
comparator = new Comparator('>=0.0.0')
|
||
}
|
||
high = high || comparator
|
||
low = low || comparator
|
||
if (gtfn(comparator.semver, high.semver, options)) {
|
||
high = comparator
|
||
} else if (ltfn(comparator.semver, low.semver, options)) {
|
||
low = comparator
|
||
}
|
||
})
|
||
|
||
// If the edge version comparator has a operator then our version
|
||
// isn't outside it
|
||
if (high.operator === comp || high.operator === ecomp) {
|
||
return false
|
||
}
|
||
|
||
// If the lowest version comparator has an operator and our version
|
||
// is less than it then it isn't higher than the range
|
||
if ((!low.operator || low.operator === comp) &&
|
||
ltefn(version, low.semver)) {
|
||
return false
|
||
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
exports.prerelease = prerelease
|
||
function prerelease (version, options) {
|
||
var parsed = parse(version, options)
|
||
return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
|
||
}
|
||
|
||
exports.intersects = intersects
|
||
function intersects (r1, r2, options) {
|
||
r1 = new Range(r1, options)
|
||
r2 = new Range(r2, options)
|
||
return r1.intersects(r2)
|
||
}
|
||
|
||
exports.coerce = coerce
|
||
function coerce (version, options) {
|
||
if (version instanceof SemVer) {
|
||
return version
|
||
}
|
||
|
||
if (typeof version === 'number') {
|
||
version = String(version)
|
||
}
|
||
|
||
if (typeof version !== 'string') {
|
||
return null
|
||
}
|
||
|
||
options = options || {}
|
||
|
||
var match = null
|
||
if (!options.rtl) {
|
||
match = version.match(re[t.COERCE])
|
||
} else {
|
||
// Find the right-most coercible string that does not share
|
||
// a terminus with a more left-ward coercible string.
|
||
// Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
|
||
//
|
||
// Walk through the string checking with a /g regexp
|
||
// Manually set the index so as to pick up overlapping matches.
|
||
// Stop when we get a match that ends at the string end, since no
|
||
// coercible string can be more right-ward without the same terminus.
|
||
var next
|
||
while ((next = re[t.COERCERTL].exec(version)) &&
|
||
(!match || match.index + match[0].length !== version.length)
|
||
) {
|
||
if (!match ||
|
||
next.index + next[0].length !== match.index + match[0].length) {
|
||
match = next
|
||
}
|
||
re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
|
||
}
|
||
// leave it in a clean state
|
||
re[t.COERCERTL].lastIndex = -1
|
||
}
|
||
|
||
if (match === null) {
|
||
return null
|
||
}
|
||
|
||
return parse(match[2] +
|
||
'.' + (match[3] || '0') +
|
||
'.' + (match[4] || '0'), options)
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
/* 281 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.create = void 0;
|
||
const internal_globber_1 = __webpack_require__(297);
|
||
/**
|
||
* Constructs a globber
|
||
*
|
||
* @param patterns Patterns separated by newlines
|
||
* @param options Glob options
|
||
*/
|
||
function create(patterns, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
return yield internal_globber_1.DefaultGlobber.create(patterns, options);
|
||
});
|
||
}
|
||
exports.create = create;
|
||
//# sourceMappingURL=glob.js.map
|
||
|
||
/***/ }),
|
||
/* 282 */,
|
||
/* 283 */,
|
||
/* 284 */,
|
||
/* 285 */,
|
||
/* 286 */,
|
||
/* 287 */,
|
||
/* 288 */,
|
||
/* 289 */,
|
||
/* 290 */,
|
||
/* 291 */,
|
||
/* 292 */,
|
||
/* 293 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _rng = _interopRequireDefault(__webpack_require__(506));
|
||
|
||
var _stringify = _interopRequireDefault(__webpack_require__(960));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function v4(options, buf, offset) {
|
||
options = options || {};
|
||
|
||
const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
|
||
|
||
|
||
rnds[6] = rnds[6] & 0x0f | 0x40;
|
||
rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
|
||
|
||
if (buf) {
|
||
offset = offset || 0;
|
||
|
||
for (let i = 0; i < 16; ++i) {
|
||
buf[offset + i] = rnds[i];
|
||
}
|
||
|
||
return buf;
|
||
}
|
||
|
||
return (0, _stringify.default)(rnds);
|
||
}
|
||
|
||
var _default = v4;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 294 */,
|
||
/* 295 */,
|
||
/* 296 */,
|
||
/* 297 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
var m = o[Symbol.asyncIterator], i;
|
||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||
};
|
||
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
|
||
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
|
||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
||
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||
function fulfill(value) { resume("next", value); }
|
||
function reject(value) { resume("throw", value); }
|
||
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.DefaultGlobber = void 0;
|
||
const core = __importStar(__webpack_require__(470));
|
||
const fs = __importStar(__webpack_require__(747));
|
||
const globOptionsHelper = __importStar(__webpack_require__(601));
|
||
const path = __importStar(__webpack_require__(622));
|
||
const patternHelper = __importStar(__webpack_require__(597));
|
||
const internal_match_kind_1 = __webpack_require__(327);
|
||
const internal_pattern_1 = __webpack_require__(923);
|
||
const internal_search_state_1 = __webpack_require__(728);
|
||
const IS_WINDOWS = process.platform === 'win32';
|
||
class DefaultGlobber {
|
||
constructor(options) {
|
||
this.patterns = [];
|
||
this.searchPaths = [];
|
||
this.options = globOptionsHelper.getOptions(options);
|
||
}
|
||
getSearchPaths() {
|
||
// Return a copy
|
||
return this.searchPaths.slice();
|
||
}
|
||
glob() {
|
||
var e_1, _a;
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const result = [];
|
||
try {
|
||
for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) {
|
||
const itemPath = _c.value;
|
||
result.push(itemPath);
|
||
}
|
||
}
|
||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||
finally {
|
||
try {
|
||
if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
|
||
}
|
||
finally { if (e_1) throw e_1.error; }
|
||
}
|
||
return result;
|
||
});
|
||
}
|
||
globGenerator() {
|
||
return __asyncGenerator(this, arguments, function* globGenerator_1() {
|
||
// Fill in defaults options
|
||
const options = globOptionsHelper.getOptions(this.options);
|
||
// Implicit descendants?
|
||
const patterns = [];
|
||
for (const pattern of this.patterns) {
|
||
patterns.push(pattern);
|
||
if (options.implicitDescendants &&
|
||
(pattern.trailingSeparator ||
|
||
pattern.segments[pattern.segments.length - 1] !== '**')) {
|
||
patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**')));
|
||
}
|
||
}
|
||
// Push the search paths
|
||
const stack = [];
|
||
for (const searchPath of patternHelper.getSearchPaths(patterns)) {
|
||
core.debug(`Search path '${searchPath}'`);
|
||
// Exists?
|
||
try {
|
||
// Intentionally using lstat. Detection for broken symlink
|
||
// will be performed later (if following symlinks).
|
||
yield __await(fs.promises.lstat(searchPath));
|
||
}
|
||
catch (err) {
|
||
if (err.code === 'ENOENT') {
|
||
continue;
|
||
}
|
||
throw err;
|
||
}
|
||
stack.unshift(new internal_search_state_1.SearchState(searchPath, 1));
|
||
}
|
||
// Search
|
||
const traversalChain = []; // used to detect cycles
|
||
while (stack.length) {
|
||
// Pop
|
||
const item = stack.pop();
|
||
// Match?
|
||
const match = patternHelper.match(patterns, item.path);
|
||
const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
|
||
if (!match && !partialMatch) {
|
||
continue;
|
||
}
|
||
// Stat
|
||
const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain)
|
||
// Broken symlink, or symlink cycle detected, or no longer exists
|
||
);
|
||
// Broken symlink, or symlink cycle detected, or no longer exists
|
||
if (!stats) {
|
||
continue;
|
||
}
|
||
// Directory
|
||
if (stats.isDirectory()) {
|
||
// Matched
|
||
if (match & internal_match_kind_1.MatchKind.Directory) {
|
||
yield yield __await(item.path);
|
||
}
|
||
// Descend?
|
||
else if (!partialMatch) {
|
||
continue;
|
||
}
|
||
// Push the child items in reverse
|
||
const childLevel = item.level + 1;
|
||
const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel));
|
||
stack.push(...childItems.reverse());
|
||
}
|
||
// File
|
||
else if (match & internal_match_kind_1.MatchKind.File) {
|
||
yield yield __await(item.path);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
/**
|
||
* Constructs a DefaultGlobber
|
||
*/
|
||
static create(patterns, options) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
const result = new DefaultGlobber(options);
|
||
if (IS_WINDOWS) {
|
||
patterns = patterns.replace(/\r\n/g, '\n');
|
||
patterns = patterns.replace(/\r/g, '\n');
|
||
}
|
||
const lines = patterns.split('\n').map(x => x.trim());
|
||
for (const line of lines) {
|
||
// Empty or comment
|
||
if (!line || line.startsWith('#')) {
|
||
continue;
|
||
}
|
||
// Pattern
|
||
else {
|
||
result.patterns.push(new internal_pattern_1.Pattern(line));
|
||
}
|
||
}
|
||
result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns));
|
||
return result;
|
||
});
|
||
}
|
||
static stat(item, options, traversalChain) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
// Note:
|
||
// `stat` returns info about the target of a symlink (or symlink chain)
|
||
// `lstat` returns info about a symlink itself
|
||
let stats;
|
||
if (options.followSymbolicLinks) {
|
||
try {
|
||
// Use `stat` (following symlinks)
|
||
stats = yield fs.promises.stat(item.path);
|
||
}
|
||
catch (err) {
|
||
if (err.code === 'ENOENT') {
|
||
if (options.omitBrokenSymbolicLinks) {
|
||
core.debug(`Broken symlink '${item.path}'`);
|
||
return undefined;
|
||
}
|
||
throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
|
||
}
|
||
throw err;
|
||
}
|
||
}
|
||
else {
|
||
// Use `lstat` (not following symlinks)
|
||
stats = yield fs.promises.lstat(item.path);
|
||
}
|
||
// Note, isDirectory() returns false for the lstat of a symlink
|
||
if (stats.isDirectory() && options.followSymbolicLinks) {
|
||
// Get the realpath
|
||
const realPath = yield fs.promises.realpath(item.path);
|
||
// Fixup the traversal chain to match the item level
|
||
while (traversalChain.length >= item.level) {
|
||
traversalChain.pop();
|
||
}
|
||
// Test for a cycle
|
||
if (traversalChain.some((x) => x === realPath)) {
|
||
core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
|
||
return undefined;
|
||
}
|
||
// Update the traversal chain
|
||
traversalChain.push(realPath);
|
||
}
|
||
return stats;
|
||
});
|
||
}
|
||
}
|
||
exports.DefaultGlobber = DefaultGlobber;
|
||
//# sourceMappingURL=internal-globber.js.map
|
||
|
||
/***/ }),
|
||
/* 298 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _v = _interopRequireDefault(__webpack_require__(241));
|
||
|
||
var _md = _interopRequireDefault(__webpack_require__(245));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
const v3 = (0, _v.default)('v3', 0x30, _md.default);
|
||
var _default = v3;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 299 */,
|
||
/* 300 */,
|
||
/* 301 */,
|
||
/* 302 */,
|
||
/* 303 */,
|
||
/* 304 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("string_decoder");
|
||
|
||
/***/ }),
|
||
/* 305 */,
|
||
/* 306 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var concatMap = __webpack_require__(896);
|
||
var balanced = __webpack_require__(621);
|
||
|
||
module.exports = expandTop;
|
||
|
||
var escSlash = '\0SLASH'+Math.random()+'\0';
|
||
var escOpen = '\0OPEN'+Math.random()+'\0';
|
||
var escClose = '\0CLOSE'+Math.random()+'\0';
|
||
var escComma = '\0COMMA'+Math.random()+'\0';
|
||
var escPeriod = '\0PERIOD'+Math.random()+'\0';
|
||
|
||
function numeric(str) {
|
||
return parseInt(str, 10) == str
|
||
? parseInt(str, 10)
|
||
: str.charCodeAt(0);
|
||
}
|
||
|
||
function escapeBraces(str) {
|
||
return str.split('\\\\').join(escSlash)
|
||
.split('\\{').join(escOpen)
|
||
.split('\\}').join(escClose)
|
||
.split('\\,').join(escComma)
|
||
.split('\\.').join(escPeriod);
|
||
}
|
||
|
||
function unescapeBraces(str) {
|
||
return str.split(escSlash).join('\\')
|
||
.split(escOpen).join('{')
|
||
.split(escClose).join('}')
|
||
.split(escComma).join(',')
|
||
.split(escPeriod).join('.');
|
||
}
|
||
|
||
|
||
// Basically just str.split(","), but handling cases
|
||
// where we have nested braced sections, which should be
|
||
// treated as individual members, like {a,{b,c},d}
|
||
function parseCommaParts(str) {
|
||
if (!str)
|
||
return [''];
|
||
|
||
var parts = [];
|
||
var m = balanced('{', '}', str);
|
||
|
||
if (!m)
|
||
return str.split(',');
|
||
|
||
var pre = m.pre;
|
||
var body = m.body;
|
||
var post = m.post;
|
||
var p = pre.split(',');
|
||
|
||
p[p.length-1] += '{' + body + '}';
|
||
var postParts = parseCommaParts(post);
|
||
if (post.length) {
|
||
p[p.length-1] += postParts.shift();
|
||
p.push.apply(p, postParts);
|
||
}
|
||
|
||
parts.push.apply(parts, p);
|
||
|
||
return parts;
|
||
}
|
||
|
||
function expandTop(str) {
|
||
if (!str)
|
||
return [];
|
||
|
||
// I don't know why Bash 4.3 does this, but it does.
|
||
// Anything starting with {} will have the first two bytes preserved
|
||
// but *only* at the top level, so {},a}b will not expand to anything,
|
||
// but a{},b}c will be expanded to [a}c,abc].
|
||
// One could argue that this is a bug in Bash, but since the goal of
|
||
// this module is to match Bash's rules, we escape a leading {}
|
||
if (str.substr(0, 2) === '{}') {
|
||
str = '\\{\\}' + str.substr(2);
|
||
}
|
||
|
||
return expand(escapeBraces(str), true).map(unescapeBraces);
|
||
}
|
||
|
||
function identity(e) {
|
||
return e;
|
||
}
|
||
|
||
function embrace(str) {
|
||
return '{' + str + '}';
|
||
}
|
||
function isPadded(el) {
|
||
return /^-?0\d/.test(el);
|
||
}
|
||
|
||
function lte(i, y) {
|
||
return i <= y;
|
||
}
|
||
function gte(i, y) {
|
||
return i >= y;
|
||
}
|
||
|
||
function expand(str, isTop) {
|
||
var expansions = [];
|
||
|
||
var m = balanced('{', '}', str);
|
||
if (!m || /\$$/.test(m.pre)) return [str];
|
||
|
||
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
|
||
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
|
||
var isSequence = isNumericSequence || isAlphaSequence;
|
||
var isOptions = m.body.indexOf(',') >= 0;
|
||
if (!isSequence && !isOptions) {
|
||
// {a},b}
|
||
if (m.post.match(/,.*\}/)) {
|
||
str = m.pre + '{' + m.body + escClose + m.post;
|
||
return expand(str);
|
||
}
|
||
return [str];
|
||
}
|
||
|
||
var n;
|
||
if (isSequence) {
|
||
n = m.body.split(/\.\./);
|
||
} else {
|
||
n = parseCommaParts(m.body);
|
||
if (n.length === 1) {
|
||
// x{{a,b}}y ==> x{a}y x{b}y
|
||
n = expand(n[0], false).map(embrace);
|
||
if (n.length === 1) {
|
||
var post = m.post.length
|
||
? expand(m.post, false)
|
||
: [''];
|
||
return post.map(function(p) {
|
||
return m.pre + n[0] + p;
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// at this point, n is the parts, and we know it's not a comma set
|
||
// with a single entry.
|
||
|
||
// no need to expand pre, since it is guaranteed to be free of brace-sets
|
||
var pre = m.pre;
|
||
var post = m.post.length
|
||
? expand(m.post, false)
|
||
: [''];
|
||
|
||
var N;
|
||
|
||
if (isSequence) {
|
||
var x = numeric(n[0]);
|
||
var y = numeric(n[1]);
|
||
var width = Math.max(n[0].length, n[1].length)
|
||
var incr = n.length == 3
|
||
? Math.abs(numeric(n[2]))
|
||
: 1;
|
||
var test = lte;
|
||
var reverse = y < x;
|
||
if (reverse) {
|
||
incr *= -1;
|
||
test = gte;
|
||
}
|
||
var pad = n.some(isPadded);
|
||
|
||
N = [];
|
||
|
||
for (var i = x; test(i, y); i += incr) {
|
||
var c;
|
||
if (isAlphaSequence) {
|
||
c = String.fromCharCode(i);
|
||
if (c === '\\')
|
||
c = '';
|
||
} else {
|
||
c = String(i);
|
||
if (pad) {
|
||
var need = width - c.length;
|
||
if (need > 0) {
|
||
var z = new Array(need + 1).join('0');
|
||
if (i < 0)
|
||
c = '-' + z + c.slice(1);
|
||
else
|
||
c = z + c;
|
||
}
|
||
}
|
||
}
|
||
N.push(c);
|
||
}
|
||
} else {
|
||
N = concatMap(n, function(el) { return expand(el, false) });
|
||
}
|
||
|
||
for (var j = 0; j < N.length; j++) {
|
||
for (var k = 0; k < post.length; k++) {
|
||
var expansion = pre + N[j] + post[k];
|
||
if (!isTop || isSequence || expansion)
|
||
expansions.push(expansion);
|
||
}
|
||
}
|
||
|
||
return expansions;
|
||
}
|
||
|
||
|
||
|
||
/***/ }),
|
||
/* 307 */,
|
||
/* 308 */,
|
||
/* 309 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||
}
|
||
Object.defineProperty(o, k2, desc);
|
||
}) : (function(o, m, k, k2) {
|
||
if (k2 === undefined) k2 = k;
|
||
o[k2] = m[k];
|
||
}));
|
||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||
}) : function(o, v) {
|
||
o["default"] = v;
|
||
});
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
||
__setModuleDefault(result, mod);
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.NullStateProvider = exports.StateProvider = void 0;
|
||
const core = __importStar(__webpack_require__(470));
|
||
const constants_1 = __webpack_require__(196);
|
||
class StateProviderBase {
|
||
constructor() {
|
||
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
|
||
this.setState = (key, value) => { };
|
||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||
this.getState = (key) => "";
|
||
}
|
||
getCacheState() {
|
||
const cacheKey = this.getState(constants_1.State.CacheMatchedKey);
|
||
if (cacheKey) {
|
||
core.debug(`Cache state/key: ${cacheKey}`);
|
||
return cacheKey;
|
||
}
|
||
return undefined;
|
||
}
|
||
}
|
||
class StateProvider extends StateProviderBase {
|
||
constructor() {
|
||
super(...arguments);
|
||
this.setState = core.saveState;
|
||
this.getState = core.getState;
|
||
}
|
||
}
|
||
exports.StateProvider = StateProvider;
|
||
class NullStateProvider extends StateProviderBase {
|
||
constructor() {
|
||
super(...arguments);
|
||
this.stateToOutputMap = new Map([
|
||
[constants_1.State.CacheMatchedKey, constants_1.Outputs.CacheMatchedKey],
|
||
[constants_1.State.CachePrimaryKey, constants_1.Outputs.CachePrimaryKey]
|
||
]);
|
||
this.setState = (key, value) => {
|
||
core.setOutput(this.stateToOutputMap.get(key), value);
|
||
};
|
||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||
this.getState = (key) => "";
|
||
}
|
||
}
|
||
exports.NullStateProvider = NullStateProvider;
|
||
|
||
|
||
/***/ }),
|
||
/* 310 */,
|
||
/* 311 */,
|
||
/* 312 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
|
||
|
||
ref = __webpack_require__(582), assign = ref.assign, isFunction = ref.isFunction;
|
||
|
||
XMLDOMImplementation = __webpack_require__(515);
|
||
|
||
XMLDocument = __webpack_require__(559);
|
||
|
||
XMLDocumentCB = __webpack_require__(768);
|
||
|
||
XMLStringWriter = __webpack_require__(750);
|
||
|
||
XMLStreamWriter = __webpack_require__(458);
|
||
|
||
NodeType = __webpack_require__(683);
|
||
|
||
WriterState = __webpack_require__(541);
|
||
|
||
module.exports.create = function(name, xmldec, doctype, options) {
|
||
var doc, root;
|
||
if (name == null) {
|
||
throw new Error("Root element needs a name.");
|
||
}
|
||
options = assign({}, xmldec, doctype, options);
|
||
doc = new XMLDocument(options);
|
||
root = doc.element(name);
|
||
if (!options.headless) {
|
||
doc.declaration(options);
|
||
if ((options.pubID != null) || (options.sysID != null)) {
|
||
doc.dtd(options);
|
||
}
|
||
}
|
||
return root;
|
||
};
|
||
|
||
module.exports.begin = function(options, onData, onEnd) {
|
||
var ref1;
|
||
if (isFunction(options)) {
|
||
ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
|
||
options = {};
|
||
}
|
||
if (onData) {
|
||
return new XMLDocumentCB(options, onData, onEnd);
|
||
} else {
|
||
return new XMLDocument(options);
|
||
}
|
||
};
|
||
|
||
module.exports.stringWriter = function(options) {
|
||
return new XMLStringWriter(options);
|
||
};
|
||
|
||
module.exports.streamWriter = function(stream, options) {
|
||
return new XMLStreamWriter(stream, options);
|
||
};
|
||
|
||
module.exports.implementation = new XMLDOMImplementation();
|
||
|
||
module.exports.nodeType = NodeType;
|
||
|
||
module.exports.writerState = WriterState;
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 313 */,
|
||
/* 314 */,
|
||
/* 315 */,
|
||
/* 316 */,
|
||
/* 317 */,
|
||
/* 318 */,
|
||
/* 319 */,
|
||
/* 320 */,
|
||
/* 321 */,
|
||
/* 322 */,
|
||
/* 323 */,
|
||
/* 324 */,
|
||
/* 325 */,
|
||
/* 326 */,
|
||
/* 327 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.MatchKind = void 0;
|
||
/**
|
||
* Indicates whether a pattern matches a path
|
||
*/
|
||
var MatchKind;
|
||
(function (MatchKind) {
|
||
/** Not matched */
|
||
MatchKind[MatchKind["None"] = 0] = "None";
|
||
/** Matched if the path is a directory */
|
||
MatchKind[MatchKind["Directory"] = 1] = "Directory";
|
||
/** Matched if the path is a regular file */
|
||
MatchKind[MatchKind["File"] = 2] = "File";
|
||
/** Matched */
|
||
MatchKind[MatchKind["All"] = 3] = "All";
|
||
})(MatchKind = exports.MatchKind || (exports.MatchKind = {}));
|
||
//# sourceMappingURL=internal-match-kind.js.map
|
||
|
||
/***/ }),
|
||
/* 328 */,
|
||
/* 329 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.default = void 0;
|
||
|
||
var _crypto = _interopRequireDefault(__webpack_require__(417));
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
function sha1(bytes) {
|
||
if (Array.isArray(bytes)) {
|
||
bytes = Buffer.from(bytes);
|
||
} else if (typeof bytes === 'string') {
|
||
bytes = Buffer.from(bytes, 'utf8');
|
||
}
|
||
|
||
return _crypto.default.createHash('sha1').update(bytes).digest();
|
||
}
|
||
|
||
var _default = sha1;
|
||
exports.default = _default;
|
||
|
||
/***/ }),
|
||
/* 330 */,
|
||
/* 331 */,
|
||
/* 332 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/*!
|
||
* Copyright (c) 2015, Salesforce.com, Inc.
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
*
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
*
|
||
* 3. Neither the name of Salesforce.com nor the names of its contributors may
|
||
* be used to endorse or promote products derived from this software without
|
||
* specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
const { fromCallback } = __webpack_require__(147);
|
||
const Store = __webpack_require__(338).Store;
|
||
const permuteDomain = __webpack_require__(89).permuteDomain;
|
||
const pathMatch = __webpack_require__(348).pathMatch;
|
||
const util = __webpack_require__(669);
|
||
|
||
class MemoryCookieStore extends Store {
|
||
constructor() {
|
||
super();
|
||
this.synchronous = true;
|
||
this.idx = {};
|
||
if (util.inspect.custom) {
|
||
this[util.inspect.custom] = this.inspect;
|
||
}
|
||
}
|
||
|
||
inspect() {
|
||
return `{ idx: ${util.inspect(this.idx, false, 2)} }`;
|
||
}
|
||
|
||
findCookie(domain, path, key, cb) {
|
||
if (!this.idx[domain]) {
|
||
return cb(null, undefined);
|
||
}
|
||
if (!this.idx[domain][path]) {
|
||
return cb(null, undefined);
|
||
}
|
||
return cb(null, this.idx[domain][path][key] || null);
|
||
}
|
||
findCookies(domain, path, allowSpecialUseDomain, cb) {
|
||
const results = [];
|
||
if (typeof allowSpecialUseDomain === "function") {
|
||
cb = allowSpecialUseDomain;
|
||
allowSpecialUseDomain = false;
|
||
}
|
||
if (!domain) {
|
||
return cb(null, []);
|
||
}
|
||
|
||
let pathMatcher;
|
||
if (!path) {
|
||
// null means "all paths"
|
||
pathMatcher = function matchAll(domainIndex) {
|
||
for (const curPath in domainIndex) {
|
||
const pathIndex = domainIndex[curPath];
|
||
for (const key in pathIndex) {
|
||
results.push(pathIndex[key]);
|
||
}
|
||
}
|
||
};
|
||
} else {
|
||
pathMatcher = function matchRFC(domainIndex) {
|
||
//NOTE: we should use path-match algorithm from S5.1.4 here
|
||
//(see : https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/canonical_cookie.cc#L299)
|
||
Object.keys(domainIndex).forEach(cookiePath => {
|
||
if (pathMatch(path, cookiePath)) {
|
||
const pathIndex = domainIndex[cookiePath];
|
||
for (const key in pathIndex) {
|
||
results.push(pathIndex[key]);
|
||
}
|
||
}
|
||
});
|
||
};
|
||
}
|
||
|
||
const domains = permuteDomain(domain, allowSpecialUseDomain) || [domain];
|
||
const idx = this.idx;
|
||
domains.forEach(curDomain => {
|
||
const domainIndex = idx[curDomain];
|
||
if (!domainIndex) {
|
||
return;
|
||
}
|
||
pathMatcher(domainIndex);
|
||
});
|
||
|
||
cb(null, results);
|
||
}
|
||
|
||
putCookie(cookie, cb) {
|
||
if (!this.idx[cookie.domain]) {
|
||
this.idx[cookie.domain] = {};
|
||
}
|
||
if (!this.idx[cookie.domain][cookie.path]) {
|
||
this.idx[cookie.domain][cookie.path] = {};
|
||
}
|
||
this.idx[cookie.domain][cookie.path][cookie.key] = cookie;
|
||
cb(null);
|
||
}
|
||
updateCookie(oldCookie, newCookie, cb) {
|
||
// updateCookie() may avoid updating cookies that are identical. For example,
|
||
// lastAccessed may not be important to some stores and an equality
|
||
// comparison could exclude that field.
|
||
this.putCookie(newCookie, cb);
|
||
}
|
||
removeCookie(domain, path, key, cb) {
|
||
if (
|
||
this.idx[domain] &&
|
||
this.idx[domain][path] &&
|
||
this.idx[domain][path][key]
|
||
) {
|
||
delete this.idx[domain][path][key];
|
||
}
|
||
cb(null);
|
||
}
|
||
removeCookies(domain, path, cb) {
|
||
if (this.idx[domain]) {
|
||
if (path) {
|
||
delete this.idx[domain][path];
|
||
} else {
|
||
delete this.idx[domain];
|
||
}
|
||
}
|
||
return cb(null);
|
||
}
|
||
removeAllCookies(cb) {
|
||
this.idx = {};
|
||
return cb(null);
|
||
}
|
||
getAllCookies(cb) {
|
||
const cookies = [];
|
||
const idx = this.idx;
|
||
|
||
const domains = Object.keys(idx);
|
||
domains.forEach(domain => {
|
||
const paths = Object.keys(idx[domain]);
|
||
paths.forEach(path => {
|
||
const keys = Object.keys(idx[domain][path]);
|
||
keys.forEach(key => {
|
||
if (key !== null) {
|
||
cookies.push(idx[domain][path][key]);
|
||
}
|
||
});
|
||
});
|
||
});
|
||
|
||
// Sort by creationIndex so deserializing retains the creation order.
|
||
// When implementing your own store, this SHOULD retain the order too
|
||
cookies.sort((a, b) => {
|
||
return (a.creationIndex || 0) - (b.creationIndex || 0);
|
||
});
|
||
|
||
cb(null, cookies);
|
||
}
|
||
}
|
||
|
||
[
|
||
"findCookie",
|
||
"findCookies",
|
||
"putCookie",
|
||
"updateCookie",
|
||
"removeCookie",
|
||
"removeCookies",
|
||
"removeAllCookies",
|
||
"getAllCookies"
|
||
].forEach(name => {
|
||
MemoryCookieStore[name] = fromCallback(MemoryCookieStore.prototype[name]);
|
||
});
|
||
|
||
exports.MemoryCookieStore = MemoryCookieStore;
|
||
|
||
|
||
/***/ }),
|
||
/* 333 */,
|
||
/* 334 */
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
module.exports =
|
||
{
|
||
parallel : __webpack_require__(424),
|
||
serial : __webpack_require__(91),
|
||
serialOrdered : __webpack_require__(892)
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
/* 335 */,
|
||
/* 336 */,
|
||
/* 337 */,
|
||
/* 338 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
/*!
|
||
* Copyright (c) 2015, Salesforce.com, Inc.
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
*
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
*
|
||
* 3. Neither the name of Salesforce.com nor the names of its contributors may
|
||
* be used to endorse or promote products derived from this software without
|
||
* specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
/*jshint unused:false */
|
||
|
||
class Store {
|
||
constructor() {
|
||
this.synchronous = false;
|
||
}
|
||
|
||
findCookie(domain, path, key, cb) {
|
||
throw new Error("findCookie is not implemented");
|
||
}
|
||
|
||
findCookies(domain, path, allowSpecialUseDomain, cb) {
|
||
throw new Error("findCookies is not implemented");
|
||
}
|
||
|
||
putCookie(cookie, cb) {
|
||
throw new Error("putCookie is not implemented");
|
||
}
|
||
|
||
updateCookie(oldCookie, newCookie, cb) {
|
||
// recommended default implementation:
|
||
// return this.putCookie(newCookie, cb);
|
||
throw new Error("updateCookie is not implemented");
|
||
}
|
||
|
||
removeCookie(domain, path, key, cb) {
|
||
throw new Error("removeCookie is not implemented");
|
||
}
|
||
|
||
removeCookies(domain, path, cb) {
|
||
throw new Error("removeCookies is not implemented");
|
||
}
|
||
|
||
removeAllCookies(cb) {
|
||
throw new Error("removeAllCookies is not implemented");
|
||
}
|
||
|
||
getAllCookies(cb) {
|
||
throw new Error(
|
||
"getAllCookies is not implemented (therefore jar cannot be serialized)"
|
||
);
|
||
}
|
||
}
|
||
|
||
exports.Store = Store;
|
||
|
||
|
||
/***/ }),
|
||
/* 339 */,
|
||
/* 340 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.SamplingDecision = void 0;
|
||
/**
|
||
* A sampling decision that determines how a {@link Span} will be recorded
|
||
* and collected.
|
||
*/
|
||
var SamplingDecision;
|
||
(function (SamplingDecision) {
|
||
/**
|
||
* `Span.isRecording() === false`, span will not be recorded and all events
|
||
* and attributes will be dropped.
|
||
*/
|
||
SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD";
|
||
/**
|
||
* `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}
|
||
* MUST NOT be set.
|
||
*/
|
||
SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD";
|
||
/**
|
||
* `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}
|
||
* MUST be set.
|
||
*/
|
||
SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
|
||
})(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
|
||
//# sourceMappingURL=SamplingResult.js.map
|
||
|
||
/***/ }),
|
||
/* 341 */,
|
||
/* 342 */,
|
||
/* 343 */,
|
||
/* 344 */,
|
||
/* 345 */,
|
||
/* 346 */,
|
||
/* 347 */,
|
||
/* 348 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
/*!
|
||
* Copyright (c) 2015, Salesforce.com, Inc.
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* 1. Redistributions of source code must retain the above copyright notice,
|
||
* this list of conditions and the following disclaimer.
|
||
*
|
||
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
||
* this list of conditions and the following disclaimer in the documentation
|
||
* and/or other materials provided with the distribution.
|
||
*
|
||
* 3. Neither the name of Salesforce.com nor the names of its contributors may
|
||
* be used to endorse or promote products derived from this software without
|
||
* specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
* POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
/*
|
||
* "A request-path path-matches a given cookie-path if at least one of the
|
||
* following conditions holds:"
|
||
*/
|
||
function pathMatch(reqPath, cookiePath) {
|
||
// "o The cookie-path and the request-path are identical."
|
||
if (cookiePath === reqPath) {
|
||
return true;
|
||
}
|
||
|
||
const idx = reqPath.indexOf(cookiePath);
|
||
if (idx === 0) {
|
||
// "o The cookie-path is a prefix of the request-path, and the last
|
||
// character of the cookie-path is %x2F ("/")."
|
||
if (cookiePath.substr(-1) === "/") {
|
||
return true;
|
||
}
|
||
|
||
// " o The cookie-path is a prefix of the request-path, and the first
|
||
// character of the request-path that is not included in the cookie- path
|
||
// is a %x2F ("/") character."
|
||
if (reqPath.substr(cookiePath.length, 1) === "/") {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
exports.pathMatch = pathMatch;
|
||
|
||
|
||
/***/ }),
|
||
/* 349 */,
|
||
/* 350 */
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
// Generated by CoffeeScript 1.12.7
|
||
(function() {
|
||
"use strict";
|
||
var prefixMatch;
|
||
|
||
prefixMatch = new RegExp(/(?!xmlns)^.*:/);
|
||
|
||
exports.normalize = function(str) {
|
||
return str.toLowerCase();
|
||
};
|
||
|
||
exports.firstCharLowerCase = function(str) {
|
||
return str.charAt(0).toLowerCase() + str.slice(1);
|
||
};
|
||
|
||
exports.stripPrefix = function(str) {
|
||
return str.replace(prefixMatch, '');
|
||
};
|
||
|
||
exports.parseNumbers = function(str) {
|
||
if (!isNaN(str)) {
|
||
str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
|
||
}
|
||
return str;
|
||
};
|
||
|
||
exports.parseBooleans = function(str) {
|
||
if (/^(?:true|false)$/i.test(str)) {
|
||
str = str.toLowerCase() === 'true';
|
||
}
|
||
return str;
|
||
};
|
||
|
||
}).call(this);
|
||
|
||
|
||
/***/ }),
|
||
/* 351 */,
|
||
/* 352 */,
|
||
/* 353 */,
|
||
/* 354 */,
|
||
/* 355 */,
|
||
/* 356 */,
|
||
/* 357 */
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("assert");
|
||
|
||
/***/ }),
|
||
/* 358 */,
|
||
/* 359 */,
|
||
/* 360 */,
|
||
/* 361 */,
|
||
/* 362 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
/*
|
||
* Copyright The OpenTelemetry Authors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* https://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.DiagComponentLogger = void 0;
|
||
var global_utils_1 = __webpack_require__(94);
|
||
/**
|
||
* Component Logger which is meant to be used as part of any component which
|
||
* will add automatically additional namespace in front of the log message.
|
||
* It will then forward all message to global diag logger
|
||
* @example
|
||
* const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
|
||
* cLogger.debug('test');
|
||
* // @opentelemetry/instrumentation-http test
|
||
*/
|
||
var DiagComponentLogger = /** @class */ (function () {
|
||
function DiagComponentLogger(props) {
|
||
this._namespace = props.namespace || 'DiagComponentLogger';
|
||
}
|
||
DiagComponentLogger.prototype.debug = function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
return logProxy('debug', this._namespace, args);
|
||
};
|
||
DiagComponentLogger.prototype.error = function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
return logProxy('error', this._namespace, args);
|
||
};
|
||
DiagComponentLogger.prototype.info = function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
return logProxy('info', this._namespace, args);
|
||
};
|
||
DiagComponentLogger.prototype.warn = function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
return logProxy('warn', this._namespace, args);
|
||
};
|
||
DiagComponentLogger.prototype.verbose = function () {
|
||
var args = [];
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i];
|
||
}
|
||
return logProxy('verbose', this._namespace, args);
|
||
};
|
||
return DiagComponentLogger;
|
||
}());
|
||
exports.DiagComponentLogger = DiagComponentLogger;
|
||
function logProxy(funcName, namespace, args) {
|
||
var logger = global_utils_1.getGlobal('diag');
|
||
// shortcut if logger not set
|
||
if (!logger) {
|
||
return;
|
||
}
|
||
args.unshift(namespace);
|
||
return logger[funcName].apply(logger, args);
|
||
}
|
||
//# sourceMappingURL=ComponentLogger.js.map
|
||
|
||
/***/ }),
|
||
/* 363 */,
|
||
/* 364 */,
|
||
/* 365 */,
|
||
/* 366 */,
|
||
/* 367 */,
|
||
/* 368 */,
|
||
/* 369 */,
|
||
/* 370 */,
|
||
/* 371 */,
|
||
/* 372 */,
|
||
/* 373 */
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
var coreHttp = __webpack_require__(999);
|
||
var tslib = __webpack_require__(608);
|
||
var coreTracing = __webpack_require__(263);
|
||
var logger$1 = __webpack_require__(928);
|
||
var abortController = __webpack_require__(106);
|
||
var os = __webpack_require__(87);
|
||
var crypto = __webpack_require__(417);
|
||
var stream = __webpack_require__(794);
|
||
__webpack_require__(510);
|
||
var coreLro = __webpack_require__(889);
|
||
var events = __webpack_require__(614);
|
||
var fs = __webpack_require__(747);
|
||
var util = __webpack_require__(669);
|
||
|
||
function _interopNamespace(e) {
|
||
if (e && e.__esModule) return e;
|
||
var n = Object.create(null);
|
||
if (e) {
|
||
Object.keys(e).forEach(function (k) {
|
||
if (k !== 'default') {
|
||
var d = Object.getOwnPropertyDescriptor(e, k);
|
||
Object.defineProperty(n, k, d.get ? d : {
|
||
enumerable: true,
|
||
get: function () { return e[k]; }
|
||
});
|
||
}
|
||
});
|
||
}
|
||
n["default"] = e;
|
||
return Object.freeze(n);
|
||
}
|
||
|
||
var coreHttp__namespace = /*#__PURE__*/_interopNamespace(coreHttp);
|
||
var os__namespace = /*#__PURE__*/_interopNamespace(os);
|
||
var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
|
||
var util__namespace = /*#__PURE__*/_interopNamespace(util);
|
||
|
||
/*
|
||
* Copyright (c) Microsoft Corporation.
|
||
* Licensed under the MIT License.
|
||
*
|
||
* Code generated by Microsoft (R) AutoRest Code Generator.
|
||
* Changes may cause incorrect behavior and will be lost if the code is regenerated.
|
||
*/
|
||
const BlobServiceProperties = {
|
||
serializedName: "BlobServiceProperties",
|
||
xmlName: "StorageServiceProperties",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobServiceProperties",
|
||
modelProperties: {
|
||
blobAnalyticsLogging: {
|
||
serializedName: "Logging",
|
||
xmlName: "Logging",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Logging"
|
||
}
|
||
},
|
||
hourMetrics: {
|
||
serializedName: "HourMetrics",
|
||
xmlName: "HourMetrics",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Metrics"
|
||
}
|
||
},
|
||
minuteMetrics: {
|
||
serializedName: "MinuteMetrics",
|
||
xmlName: "MinuteMetrics",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Metrics"
|
||
}
|
||
},
|
||
cors: {
|
||
serializedName: "Cors",
|
||
xmlName: "Cors",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "CorsRule",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "CorsRule"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
defaultServiceVersion: {
|
||
serializedName: "DefaultServiceVersion",
|
||
xmlName: "DefaultServiceVersion",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
deleteRetentionPolicy: {
|
||
serializedName: "DeleteRetentionPolicy",
|
||
xmlName: "DeleteRetentionPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "RetentionPolicy"
|
||
}
|
||
},
|
||
staticWebsite: {
|
||
serializedName: "StaticWebsite",
|
||
xmlName: "StaticWebsite",
|
||
type: {
|
||
name: "Composite",
|
||
className: "StaticWebsite"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const Logging = {
|
||
serializedName: "Logging",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Logging",
|
||
modelProperties: {
|
||
version: {
|
||
serializedName: "Version",
|
||
required: true,
|
||
xmlName: "Version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
deleteProperty: {
|
||
serializedName: "Delete",
|
||
required: true,
|
||
xmlName: "Delete",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
read: {
|
||
serializedName: "Read",
|
||
required: true,
|
||
xmlName: "Read",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
write: {
|
||
serializedName: "Write",
|
||
required: true,
|
||
xmlName: "Write",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
retentionPolicy: {
|
||
serializedName: "RetentionPolicy",
|
||
xmlName: "RetentionPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "RetentionPolicy"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const RetentionPolicy = {
|
||
serializedName: "RetentionPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "RetentionPolicy",
|
||
modelProperties: {
|
||
enabled: {
|
||
serializedName: "Enabled",
|
||
required: true,
|
||
xmlName: "Enabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
days: {
|
||
constraints: {
|
||
InclusiveMinimum: 1
|
||
},
|
||
serializedName: "Days",
|
||
xmlName: "Days",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const Metrics = {
|
||
serializedName: "Metrics",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Metrics",
|
||
modelProperties: {
|
||
version: {
|
||
serializedName: "Version",
|
||
xmlName: "Version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
enabled: {
|
||
serializedName: "Enabled",
|
||
required: true,
|
||
xmlName: "Enabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
includeAPIs: {
|
||
serializedName: "IncludeAPIs",
|
||
xmlName: "IncludeAPIs",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
retentionPolicy: {
|
||
serializedName: "RetentionPolicy",
|
||
xmlName: "RetentionPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "RetentionPolicy"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const CorsRule = {
|
||
serializedName: "CorsRule",
|
||
type: {
|
||
name: "Composite",
|
||
className: "CorsRule",
|
||
modelProperties: {
|
||
allowedOrigins: {
|
||
serializedName: "AllowedOrigins",
|
||
required: true,
|
||
xmlName: "AllowedOrigins",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
allowedMethods: {
|
||
serializedName: "AllowedMethods",
|
||
required: true,
|
||
xmlName: "AllowedMethods",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
allowedHeaders: {
|
||
serializedName: "AllowedHeaders",
|
||
required: true,
|
||
xmlName: "AllowedHeaders",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
exposedHeaders: {
|
||
serializedName: "ExposedHeaders",
|
||
required: true,
|
||
xmlName: "ExposedHeaders",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
maxAgeInSeconds: {
|
||
constraints: {
|
||
InclusiveMinimum: 0
|
||
},
|
||
serializedName: "MaxAgeInSeconds",
|
||
required: true,
|
||
xmlName: "MaxAgeInSeconds",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const StaticWebsite = {
|
||
serializedName: "StaticWebsite",
|
||
type: {
|
||
name: "Composite",
|
||
className: "StaticWebsite",
|
||
modelProperties: {
|
||
enabled: {
|
||
serializedName: "Enabled",
|
||
required: true,
|
||
xmlName: "Enabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
indexDocument: {
|
||
serializedName: "IndexDocument",
|
||
xmlName: "IndexDocument",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
errorDocument404Path: {
|
||
serializedName: "ErrorDocument404Path",
|
||
xmlName: "ErrorDocument404Path",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
defaultIndexDocumentPath: {
|
||
serializedName: "DefaultIndexDocumentPath",
|
||
xmlName: "DefaultIndexDocumentPath",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const StorageError = {
|
||
serializedName: "StorageError",
|
||
type: {
|
||
name: "Composite",
|
||
className: "StorageError",
|
||
modelProperties: {
|
||
message: {
|
||
serializedName: "Message",
|
||
xmlName: "Message",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
code: {
|
||
serializedName: "Code",
|
||
xmlName: "Code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobServiceStatistics = {
|
||
serializedName: "BlobServiceStatistics",
|
||
xmlName: "StorageServiceStats",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobServiceStatistics",
|
||
modelProperties: {
|
||
geoReplication: {
|
||
serializedName: "GeoReplication",
|
||
xmlName: "GeoReplication",
|
||
type: {
|
||
name: "Composite",
|
||
className: "GeoReplication"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const GeoReplication = {
|
||
serializedName: "GeoReplication",
|
||
type: {
|
||
name: "Composite",
|
||
className: "GeoReplication",
|
||
modelProperties: {
|
||
status: {
|
||
serializedName: "Status",
|
||
required: true,
|
||
xmlName: "Status",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["live", "bootstrap", "unavailable"]
|
||
}
|
||
},
|
||
lastSyncOn: {
|
||
serializedName: "LastSyncTime",
|
||
required: true,
|
||
xmlName: "LastSyncTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ListContainersSegmentResponse = {
|
||
serializedName: "ListContainersSegmentResponse",
|
||
xmlName: "EnumerationResults",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ListContainersSegmentResponse",
|
||
modelProperties: {
|
||
serviceEndpoint: {
|
||
serializedName: "ServiceEndpoint",
|
||
required: true,
|
||
xmlName: "ServiceEndpoint",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
prefix: {
|
||
serializedName: "Prefix",
|
||
xmlName: "Prefix",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
marker: {
|
||
serializedName: "Marker",
|
||
xmlName: "Marker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
maxPageSize: {
|
||
serializedName: "MaxResults",
|
||
xmlName: "MaxResults",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
containerItems: {
|
||
serializedName: "ContainerItems",
|
||
required: true,
|
||
xmlName: "Containers",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Container",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerItem"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
continuationToken: {
|
||
serializedName: "NextMarker",
|
||
xmlName: "NextMarker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerItem = {
|
||
serializedName: "ContainerItem",
|
||
xmlName: "Container",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerItem",
|
||
modelProperties: {
|
||
name: {
|
||
serializedName: "Name",
|
||
required: true,
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
deleted: {
|
||
serializedName: "Deleted",
|
||
xmlName: "Deleted",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "Version",
|
||
xmlName: "Version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
properties: {
|
||
serializedName: "Properties",
|
||
xmlName: "Properties",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerProperties"
|
||
}
|
||
},
|
||
metadata: {
|
||
serializedName: "Metadata",
|
||
xmlName: "Metadata",
|
||
type: {
|
||
name: "Dictionary",
|
||
value: { type: { name: "String" } }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerProperties = {
|
||
serializedName: "ContainerProperties",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerProperties",
|
||
modelProperties: {
|
||
lastModified: {
|
||
serializedName: "Last-Modified",
|
||
required: true,
|
||
xmlName: "Last-Modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
etag: {
|
||
serializedName: "Etag",
|
||
required: true,
|
||
xmlName: "Etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
leaseStatus: {
|
||
serializedName: "LeaseStatus",
|
||
xmlName: "LeaseStatus",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["locked", "unlocked"]
|
||
}
|
||
},
|
||
leaseState: {
|
||
serializedName: "LeaseState",
|
||
xmlName: "LeaseState",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"available",
|
||
"leased",
|
||
"expired",
|
||
"breaking",
|
||
"broken"
|
||
]
|
||
}
|
||
},
|
||
leaseDuration: {
|
||
serializedName: "LeaseDuration",
|
||
xmlName: "LeaseDuration",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["infinite", "fixed"]
|
||
}
|
||
},
|
||
publicAccess: {
|
||
serializedName: "PublicAccess",
|
||
xmlName: "PublicAccess",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["container", "blob"]
|
||
}
|
||
},
|
||
hasImmutabilityPolicy: {
|
||
serializedName: "HasImmutabilityPolicy",
|
||
xmlName: "HasImmutabilityPolicy",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
hasLegalHold: {
|
||
serializedName: "HasLegalHold",
|
||
xmlName: "HasLegalHold",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
defaultEncryptionScope: {
|
||
serializedName: "DefaultEncryptionScope",
|
||
xmlName: "DefaultEncryptionScope",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
preventEncryptionScopeOverride: {
|
||
serializedName: "DenyEncryptionScopeOverride",
|
||
xmlName: "DenyEncryptionScopeOverride",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
deletedOn: {
|
||
serializedName: "DeletedTime",
|
||
xmlName: "DeletedTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
remainingRetentionDays: {
|
||
serializedName: "RemainingRetentionDays",
|
||
xmlName: "RemainingRetentionDays",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
isImmutableStorageWithVersioningEnabled: {
|
||
serializedName: "ImmutableStorageWithVersioningEnabled",
|
||
xmlName: "ImmutableStorageWithVersioningEnabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const KeyInfo = {
|
||
serializedName: "KeyInfo",
|
||
type: {
|
||
name: "Composite",
|
||
className: "KeyInfo",
|
||
modelProperties: {
|
||
startsOn: {
|
||
serializedName: "Start",
|
||
required: true,
|
||
xmlName: "Start",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
expiresOn: {
|
||
serializedName: "Expiry",
|
||
required: true,
|
||
xmlName: "Expiry",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const UserDelegationKey = {
|
||
serializedName: "UserDelegationKey",
|
||
type: {
|
||
name: "Composite",
|
||
className: "UserDelegationKey",
|
||
modelProperties: {
|
||
signedObjectId: {
|
||
serializedName: "SignedOid",
|
||
required: true,
|
||
xmlName: "SignedOid",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
signedTenantId: {
|
||
serializedName: "SignedTid",
|
||
required: true,
|
||
xmlName: "SignedTid",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
signedStartsOn: {
|
||
serializedName: "SignedStart",
|
||
required: true,
|
||
xmlName: "SignedStart",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
signedExpiresOn: {
|
||
serializedName: "SignedExpiry",
|
||
required: true,
|
||
xmlName: "SignedExpiry",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
signedService: {
|
||
serializedName: "SignedService",
|
||
required: true,
|
||
xmlName: "SignedService",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
signedVersion: {
|
||
serializedName: "SignedVersion",
|
||
required: true,
|
||
xmlName: "SignedVersion",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
value: {
|
||
serializedName: "Value",
|
||
required: true,
|
||
xmlName: "Value",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const FilterBlobSegment = {
|
||
serializedName: "FilterBlobSegment",
|
||
xmlName: "EnumerationResults",
|
||
type: {
|
||
name: "Composite",
|
||
className: "FilterBlobSegment",
|
||
modelProperties: {
|
||
serviceEndpoint: {
|
||
serializedName: "ServiceEndpoint",
|
||
required: true,
|
||
xmlName: "ServiceEndpoint",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
where: {
|
||
serializedName: "Where",
|
||
required: true,
|
||
xmlName: "Where",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
blobs: {
|
||
serializedName: "Blobs",
|
||
required: true,
|
||
xmlName: "Blobs",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Blob",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "FilterBlobItem"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
continuationToken: {
|
||
serializedName: "NextMarker",
|
||
xmlName: "NextMarker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const FilterBlobItem = {
|
||
serializedName: "FilterBlobItem",
|
||
xmlName: "Blob",
|
||
type: {
|
||
name: "Composite",
|
||
className: "FilterBlobItem",
|
||
modelProperties: {
|
||
name: {
|
||
serializedName: "Name",
|
||
required: true,
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
containerName: {
|
||
serializedName: "ContainerName",
|
||
required: true,
|
||
xmlName: "ContainerName",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
tags: {
|
||
serializedName: "Tags",
|
||
xmlName: "Tags",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobTags"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobTags = {
|
||
serializedName: "BlobTags",
|
||
xmlName: "Tags",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobTags",
|
||
modelProperties: {
|
||
blobTagSet: {
|
||
serializedName: "BlobTagSet",
|
||
required: true,
|
||
xmlName: "TagSet",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Tag",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobTag"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobTag = {
|
||
serializedName: "BlobTag",
|
||
xmlName: "Tag",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobTag",
|
||
modelProperties: {
|
||
key: {
|
||
serializedName: "Key",
|
||
required: true,
|
||
xmlName: "Key",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
value: {
|
||
serializedName: "Value",
|
||
required: true,
|
||
xmlName: "Value",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const SignedIdentifier = {
|
||
serializedName: "SignedIdentifier",
|
||
xmlName: "SignedIdentifier",
|
||
type: {
|
||
name: "Composite",
|
||
className: "SignedIdentifier",
|
||
modelProperties: {
|
||
id: {
|
||
serializedName: "Id",
|
||
required: true,
|
||
xmlName: "Id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
accessPolicy: {
|
||
serializedName: "AccessPolicy",
|
||
xmlName: "AccessPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "AccessPolicy"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const AccessPolicy = {
|
||
serializedName: "AccessPolicy",
|
||
type: {
|
||
name: "Composite",
|
||
className: "AccessPolicy",
|
||
modelProperties: {
|
||
startsOn: {
|
||
serializedName: "Start",
|
||
xmlName: "Start",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
expiresOn: {
|
||
serializedName: "Expiry",
|
||
xmlName: "Expiry",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
permissions: {
|
||
serializedName: "Permission",
|
||
xmlName: "Permission",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ListBlobsFlatSegmentResponse = {
|
||
serializedName: "ListBlobsFlatSegmentResponse",
|
||
xmlName: "EnumerationResults",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ListBlobsFlatSegmentResponse",
|
||
modelProperties: {
|
||
serviceEndpoint: {
|
||
serializedName: "ServiceEndpoint",
|
||
required: true,
|
||
xmlName: "ServiceEndpoint",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
containerName: {
|
||
serializedName: "ContainerName",
|
||
required: true,
|
||
xmlName: "ContainerName",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
prefix: {
|
||
serializedName: "Prefix",
|
||
xmlName: "Prefix",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
marker: {
|
||
serializedName: "Marker",
|
||
xmlName: "Marker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
maxPageSize: {
|
||
serializedName: "MaxResults",
|
||
xmlName: "MaxResults",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
segment: {
|
||
serializedName: "Segment",
|
||
xmlName: "Blobs",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobFlatListSegment"
|
||
}
|
||
},
|
||
continuationToken: {
|
||
serializedName: "NextMarker",
|
||
xmlName: "NextMarker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobFlatListSegment = {
|
||
serializedName: "BlobFlatListSegment",
|
||
xmlName: "Blobs",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobFlatListSegment",
|
||
modelProperties: {
|
||
blobItems: {
|
||
serializedName: "BlobItems",
|
||
required: true,
|
||
xmlName: "BlobItems",
|
||
xmlElementName: "Blob",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobItemInternal"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobItemInternal = {
|
||
serializedName: "BlobItemInternal",
|
||
xmlName: "Blob",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobItemInternal",
|
||
modelProperties: {
|
||
name: {
|
||
serializedName: "Name",
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobName"
|
||
}
|
||
},
|
||
deleted: {
|
||
serializedName: "Deleted",
|
||
required: true,
|
||
xmlName: "Deleted",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
snapshot: {
|
||
serializedName: "Snapshot",
|
||
required: true,
|
||
xmlName: "Snapshot",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
versionId: {
|
||
serializedName: "VersionId",
|
||
xmlName: "VersionId",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
isCurrentVersion: {
|
||
serializedName: "IsCurrentVersion",
|
||
xmlName: "IsCurrentVersion",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
properties: {
|
||
serializedName: "Properties",
|
||
xmlName: "Properties",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobPropertiesInternal"
|
||
}
|
||
},
|
||
metadata: {
|
||
serializedName: "Metadata",
|
||
xmlName: "Metadata",
|
||
type: {
|
||
name: "Dictionary",
|
||
value: { type: { name: "String" } }
|
||
}
|
||
},
|
||
blobTags: {
|
||
serializedName: "BlobTags",
|
||
xmlName: "Tags",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobTags"
|
||
}
|
||
},
|
||
objectReplicationMetadata: {
|
||
serializedName: "ObjectReplicationMetadata",
|
||
xmlName: "OrMetadata",
|
||
type: {
|
||
name: "Dictionary",
|
||
value: { type: { name: "String" } }
|
||
}
|
||
},
|
||
hasVersionsOnly: {
|
||
serializedName: "HasVersionsOnly",
|
||
xmlName: "HasVersionsOnly",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobName = {
|
||
serializedName: "BlobName",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobName",
|
||
modelProperties: {
|
||
encoded: {
|
||
serializedName: "Encoded",
|
||
xmlName: "Encoded",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
content: {
|
||
serializedName: "content",
|
||
xmlName: "content",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobPropertiesInternal = {
|
||
serializedName: "BlobPropertiesInternal",
|
||
xmlName: "Properties",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobPropertiesInternal",
|
||
modelProperties: {
|
||
createdOn: {
|
||
serializedName: "Creation-Time",
|
||
xmlName: "Creation-Time",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
lastModified: {
|
||
serializedName: "Last-Modified",
|
||
required: true,
|
||
xmlName: "Last-Modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
etag: {
|
||
serializedName: "Etag",
|
||
required: true,
|
||
xmlName: "Etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
contentLength: {
|
||
serializedName: "Content-Length",
|
||
xmlName: "Content-Length",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
contentType: {
|
||
serializedName: "Content-Type",
|
||
xmlName: "Content-Type",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
contentEncoding: {
|
||
serializedName: "Content-Encoding",
|
||
xmlName: "Content-Encoding",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
contentLanguage: {
|
||
serializedName: "Content-Language",
|
||
xmlName: "Content-Language",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
contentMD5: {
|
||
serializedName: "Content-MD5",
|
||
xmlName: "Content-MD5",
|
||
type: {
|
||
name: "ByteArray"
|
||
}
|
||
},
|
||
contentDisposition: {
|
||
serializedName: "Content-Disposition",
|
||
xmlName: "Content-Disposition",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
cacheControl: {
|
||
serializedName: "Cache-Control",
|
||
xmlName: "Cache-Control",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
blobSequenceNumber: {
|
||
serializedName: "x-ms-blob-sequence-number",
|
||
xmlName: "x-ms-blob-sequence-number",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
blobType: {
|
||
serializedName: "BlobType",
|
||
xmlName: "BlobType",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["BlockBlob", "PageBlob", "AppendBlob"]
|
||
}
|
||
},
|
||
leaseStatus: {
|
||
serializedName: "LeaseStatus",
|
||
xmlName: "LeaseStatus",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["locked", "unlocked"]
|
||
}
|
||
},
|
||
leaseState: {
|
||
serializedName: "LeaseState",
|
||
xmlName: "LeaseState",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"available",
|
||
"leased",
|
||
"expired",
|
||
"breaking",
|
||
"broken"
|
||
]
|
||
}
|
||
},
|
||
leaseDuration: {
|
||
serializedName: "LeaseDuration",
|
||
xmlName: "LeaseDuration",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["infinite", "fixed"]
|
||
}
|
||
},
|
||
copyId: {
|
||
serializedName: "CopyId",
|
||
xmlName: "CopyId",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
copyStatus: {
|
||
serializedName: "CopyStatus",
|
||
xmlName: "CopyStatus",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["pending", "success", "aborted", "failed"]
|
||
}
|
||
},
|
||
copySource: {
|
||
serializedName: "CopySource",
|
||
xmlName: "CopySource",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
copyProgress: {
|
||
serializedName: "CopyProgress",
|
||
xmlName: "CopyProgress",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
copyCompletedOn: {
|
||
serializedName: "CopyCompletionTime",
|
||
xmlName: "CopyCompletionTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
copyStatusDescription: {
|
||
serializedName: "CopyStatusDescription",
|
||
xmlName: "CopyStatusDescription",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
serverEncrypted: {
|
||
serializedName: "ServerEncrypted",
|
||
xmlName: "ServerEncrypted",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
incrementalCopy: {
|
||
serializedName: "IncrementalCopy",
|
||
xmlName: "IncrementalCopy",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
destinationSnapshot: {
|
||
serializedName: "DestinationSnapshot",
|
||
xmlName: "DestinationSnapshot",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
deletedOn: {
|
||
serializedName: "DeletedTime",
|
||
xmlName: "DeletedTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
remainingRetentionDays: {
|
||
serializedName: "RemainingRetentionDays",
|
||
xmlName: "RemainingRetentionDays",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
accessTier: {
|
||
serializedName: "AccessTier",
|
||
xmlName: "AccessTier",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"P4",
|
||
"P6",
|
||
"P10",
|
||
"P15",
|
||
"P20",
|
||
"P30",
|
||
"P40",
|
||
"P50",
|
||
"P60",
|
||
"P70",
|
||
"P80",
|
||
"Hot",
|
||
"Cool",
|
||
"Archive"
|
||
]
|
||
}
|
||
},
|
||
accessTierInferred: {
|
||
serializedName: "AccessTierInferred",
|
||
xmlName: "AccessTierInferred",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
archiveStatus: {
|
||
serializedName: "ArchiveStatus",
|
||
xmlName: "ArchiveStatus",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"rehydrate-pending-to-hot",
|
||
"rehydrate-pending-to-cool"
|
||
]
|
||
}
|
||
},
|
||
customerProvidedKeySha256: {
|
||
serializedName: "CustomerProvidedKeySha256",
|
||
xmlName: "CustomerProvidedKeySha256",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
encryptionScope: {
|
||
serializedName: "EncryptionScope",
|
||
xmlName: "EncryptionScope",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
accessTierChangedOn: {
|
||
serializedName: "AccessTierChangeTime",
|
||
xmlName: "AccessTierChangeTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
tagCount: {
|
||
serializedName: "TagCount",
|
||
xmlName: "TagCount",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
expiresOn: {
|
||
serializedName: "Expiry-Time",
|
||
xmlName: "Expiry-Time",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
isSealed: {
|
||
serializedName: "Sealed",
|
||
xmlName: "Sealed",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
rehydratePriority: {
|
||
serializedName: "RehydratePriority",
|
||
xmlName: "RehydratePriority",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["High", "Standard"]
|
||
}
|
||
},
|
||
lastAccessedOn: {
|
||
serializedName: "LastAccessTime",
|
||
xmlName: "LastAccessTime",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
immutabilityPolicyExpiresOn: {
|
||
serializedName: "ImmutabilityPolicyUntilDate",
|
||
xmlName: "ImmutabilityPolicyUntilDate",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
immutabilityPolicyMode: {
|
||
serializedName: "ImmutabilityPolicyMode",
|
||
xmlName: "ImmutabilityPolicyMode",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["Mutable", "Unlocked", "Locked"]
|
||
}
|
||
},
|
||
legalHold: {
|
||
serializedName: "LegalHold",
|
||
xmlName: "LegalHold",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ListBlobsHierarchySegmentResponse = {
|
||
serializedName: "ListBlobsHierarchySegmentResponse",
|
||
xmlName: "EnumerationResults",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ListBlobsHierarchySegmentResponse",
|
||
modelProperties: {
|
||
serviceEndpoint: {
|
||
serializedName: "ServiceEndpoint",
|
||
required: true,
|
||
xmlName: "ServiceEndpoint",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
containerName: {
|
||
serializedName: "ContainerName",
|
||
required: true,
|
||
xmlName: "ContainerName",
|
||
xmlIsAttribute: true,
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
prefix: {
|
||
serializedName: "Prefix",
|
||
xmlName: "Prefix",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
marker: {
|
||
serializedName: "Marker",
|
||
xmlName: "Marker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
maxPageSize: {
|
||
serializedName: "MaxResults",
|
||
xmlName: "MaxResults",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
delimiter: {
|
||
serializedName: "Delimiter",
|
||
xmlName: "Delimiter",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
segment: {
|
||
serializedName: "Segment",
|
||
xmlName: "Blobs",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobHierarchyListSegment"
|
||
}
|
||
},
|
||
continuationToken: {
|
||
serializedName: "NextMarker",
|
||
xmlName: "NextMarker",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobHierarchyListSegment = {
|
||
serializedName: "BlobHierarchyListSegment",
|
||
xmlName: "Blobs",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobHierarchyListSegment",
|
||
modelProperties: {
|
||
blobPrefixes: {
|
||
serializedName: "BlobPrefixes",
|
||
xmlName: "BlobPrefixes",
|
||
xmlElementName: "BlobPrefix",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobPrefix"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
blobItems: {
|
||
serializedName: "BlobItems",
|
||
required: true,
|
||
xmlName: "BlobItems",
|
||
xmlElementName: "Blob",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobItemInternal"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlobPrefix = {
|
||
serializedName: "BlobPrefix",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobPrefix",
|
||
modelProperties: {
|
||
name: {
|
||
serializedName: "Name",
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlobName"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlockLookupList = {
|
||
serializedName: "BlockLookupList",
|
||
xmlName: "BlockList",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlockLookupList",
|
||
modelProperties: {
|
||
committed: {
|
||
serializedName: "Committed",
|
||
xmlName: "Committed",
|
||
xmlElementName: "Committed",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
uncommitted: {
|
||
serializedName: "Uncommitted",
|
||
xmlName: "Uncommitted",
|
||
xmlElementName: "Uncommitted",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
latest: {
|
||
serializedName: "Latest",
|
||
xmlName: "Latest",
|
||
xmlElementName: "Latest",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const BlockList = {
|
||
serializedName: "BlockList",
|
||
type: {
|
||
name: "Composite",
|
||
className: "BlockList",
|
||
modelProperties: {
|
||
committedBlocks: {
|
||
serializedName: "CommittedBlocks",
|
||
xmlName: "CommittedBlocks",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Block",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "Block"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
uncommittedBlocks: {
|
||
serializedName: "UncommittedBlocks",
|
||
xmlName: "UncommittedBlocks",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Block",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "Block"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const Block = {
|
||
serializedName: "Block",
|
||
type: {
|
||
name: "Composite",
|
||
className: "Block",
|
||
modelProperties: {
|
||
name: {
|
||
serializedName: "Name",
|
||
required: true,
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
size: {
|
||
serializedName: "Size",
|
||
required: true,
|
||
xmlName: "Size",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const PageList = {
|
||
serializedName: "PageList",
|
||
type: {
|
||
name: "Composite",
|
||
className: "PageList",
|
||
modelProperties: {
|
||
pageRange: {
|
||
serializedName: "PageRange",
|
||
xmlName: "PageRange",
|
||
xmlElementName: "PageRange",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "PageRange"
|
||
}
|
||
}
|
||
}
|
||
},
|
||
clearRange: {
|
||
serializedName: "ClearRange",
|
||
xmlName: "ClearRange",
|
||
xmlElementName: "ClearRange",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "ClearRange"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const PageRange = {
|
||
serializedName: "PageRange",
|
||
xmlName: "PageRange",
|
||
type: {
|
||
name: "Composite",
|
||
className: "PageRange",
|
||
modelProperties: {
|
||
start: {
|
||
serializedName: "Start",
|
||
required: true,
|
||
xmlName: "Start",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
end: {
|
||
serializedName: "End",
|
||
required: true,
|
||
xmlName: "End",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ClearRange = {
|
||
serializedName: "ClearRange",
|
||
xmlName: "ClearRange",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ClearRange",
|
||
modelProperties: {
|
||
start: {
|
||
serializedName: "Start",
|
||
required: true,
|
||
xmlName: "Start",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
end: {
|
||
serializedName: "End",
|
||
required: true,
|
||
xmlName: "End",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const QueryRequest = {
|
||
serializedName: "QueryRequest",
|
||
xmlName: "QueryRequest",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QueryRequest",
|
||
modelProperties: {
|
||
queryType: {
|
||
serializedName: "QueryType",
|
||
required: true,
|
||
xmlName: "QueryType",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
expression: {
|
||
serializedName: "Expression",
|
||
required: true,
|
||
xmlName: "Expression",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
inputSerialization: {
|
||
serializedName: "InputSerialization",
|
||
xmlName: "InputSerialization",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QuerySerialization"
|
||
}
|
||
},
|
||
outputSerialization: {
|
||
serializedName: "OutputSerialization",
|
||
xmlName: "OutputSerialization",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QuerySerialization"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const QuerySerialization = {
|
||
serializedName: "QuerySerialization",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QuerySerialization",
|
||
modelProperties: {
|
||
format: {
|
||
serializedName: "Format",
|
||
xmlName: "Format",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QueryFormat"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const QueryFormat = {
|
||
serializedName: "QueryFormat",
|
||
type: {
|
||
name: "Composite",
|
||
className: "QueryFormat",
|
||
modelProperties: {
|
||
type: {
|
||
serializedName: "Type",
|
||
required: true,
|
||
xmlName: "Type",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["delimited", "json", "arrow", "parquet"]
|
||
}
|
||
},
|
||
delimitedTextConfiguration: {
|
||
serializedName: "DelimitedTextConfiguration",
|
||
xmlName: "DelimitedTextConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "DelimitedTextConfiguration"
|
||
}
|
||
},
|
||
jsonTextConfiguration: {
|
||
serializedName: "JsonTextConfiguration",
|
||
xmlName: "JsonTextConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "JsonTextConfiguration"
|
||
}
|
||
},
|
||
arrowConfiguration: {
|
||
serializedName: "ArrowConfiguration",
|
||
xmlName: "ArrowConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ArrowConfiguration"
|
||
}
|
||
},
|
||
parquetTextConfiguration: {
|
||
serializedName: "ParquetTextConfiguration",
|
||
xmlName: "ParquetTextConfiguration",
|
||
type: {
|
||
name: "any"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const DelimitedTextConfiguration = {
|
||
serializedName: "DelimitedTextConfiguration",
|
||
xmlName: "DelimitedTextConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "DelimitedTextConfiguration",
|
||
modelProperties: {
|
||
columnSeparator: {
|
||
serializedName: "ColumnSeparator",
|
||
xmlName: "ColumnSeparator",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
fieldQuote: {
|
||
serializedName: "FieldQuote",
|
||
xmlName: "FieldQuote",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
recordSeparator: {
|
||
serializedName: "RecordSeparator",
|
||
xmlName: "RecordSeparator",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
escapeChar: {
|
||
serializedName: "EscapeChar",
|
||
xmlName: "EscapeChar",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
headersPresent: {
|
||
serializedName: "HeadersPresent",
|
||
xmlName: "HasHeaders",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const JsonTextConfiguration = {
|
||
serializedName: "JsonTextConfiguration",
|
||
xmlName: "JsonTextConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "JsonTextConfiguration",
|
||
modelProperties: {
|
||
recordSeparator: {
|
||
serializedName: "RecordSeparator",
|
||
xmlName: "RecordSeparator",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ArrowConfiguration = {
|
||
serializedName: "ArrowConfiguration",
|
||
xmlName: "ArrowConfiguration",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ArrowConfiguration",
|
||
modelProperties: {
|
||
schema: {
|
||
serializedName: "Schema",
|
||
required: true,
|
||
xmlName: "Schema",
|
||
xmlIsWrapped: true,
|
||
xmlElementName: "Field",
|
||
type: {
|
||
name: "Sequence",
|
||
element: {
|
||
type: {
|
||
name: "Composite",
|
||
className: "ArrowField"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ArrowField = {
|
||
serializedName: "ArrowField",
|
||
xmlName: "Field",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ArrowField",
|
||
modelProperties: {
|
||
type: {
|
||
serializedName: "Type",
|
||
required: true,
|
||
xmlName: "Type",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
name: {
|
||
serializedName: "Name",
|
||
xmlName: "Name",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
precision: {
|
||
serializedName: "Precision",
|
||
xmlName: "Precision",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
},
|
||
scale: {
|
||
serializedName: "Scale",
|
||
xmlName: "Scale",
|
||
type: {
|
||
name: "Number"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceSetPropertiesHeaders = {
|
||
serializedName: "Service_setPropertiesHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceSetPropertiesHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceSetPropertiesExceptionHeaders = {
|
||
serializedName: "Service_setPropertiesExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceSetPropertiesExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetPropertiesHeaders = {
|
||
serializedName: "Service_getPropertiesHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetPropertiesHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetPropertiesExceptionHeaders = {
|
||
serializedName: "Service_getPropertiesExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetPropertiesExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetStatisticsHeaders = {
|
||
serializedName: "Service_getStatisticsHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetStatisticsHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetStatisticsExceptionHeaders = {
|
||
serializedName: "Service_getStatisticsExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetStatisticsExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceListContainersSegmentHeaders = {
|
||
serializedName: "Service_listContainersSegmentHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceListContainersSegmentHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceListContainersSegmentExceptionHeaders = {
|
||
serializedName: "Service_listContainersSegmentExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceListContainersSegmentExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetUserDelegationKeyHeaders = {
|
||
serializedName: "Service_getUserDelegationKeyHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetUserDelegationKeyHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetUserDelegationKeyExceptionHeaders = {
|
||
serializedName: "Service_getUserDelegationKeyExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetUserDelegationKeyExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetAccountInfoHeaders = {
|
||
serializedName: "Service_getAccountInfoHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetAccountInfoHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
skuName: {
|
||
serializedName: "x-ms-sku-name",
|
||
xmlName: "x-ms-sku-name",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"Standard_LRS",
|
||
"Standard_GRS",
|
||
"Standard_RAGRS",
|
||
"Standard_ZRS",
|
||
"Premium_LRS"
|
||
]
|
||
}
|
||
},
|
||
accountKind: {
|
||
serializedName: "x-ms-account-kind",
|
||
xmlName: "x-ms-account-kind",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"Storage",
|
||
"BlobStorage",
|
||
"StorageV2",
|
||
"FileStorage",
|
||
"BlockBlobStorage"
|
||
]
|
||
}
|
||
},
|
||
isHierarchicalNamespaceEnabled: {
|
||
serializedName: "x-ms-is-hns-enabled",
|
||
xmlName: "x-ms-is-hns-enabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceGetAccountInfoExceptionHeaders = {
|
||
serializedName: "Service_getAccountInfoExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceGetAccountInfoExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceSubmitBatchHeaders = {
|
||
serializedName: "Service_submitBatchHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceSubmitBatchHeaders",
|
||
modelProperties: {
|
||
contentType: {
|
||
serializedName: "content-type",
|
||
xmlName: "content-type",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceSubmitBatchExceptionHeaders = {
|
||
serializedName: "Service_submitBatchExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceSubmitBatchExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceFilterBlobsHeaders = {
|
||
serializedName: "Service_filterBlobsHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceFilterBlobsHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ServiceFilterBlobsExceptionHeaders = {
|
||
serializedName: "Service_filterBlobsExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ServiceFilterBlobsExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerCreateHeaders = {
|
||
serializedName: "Container_createHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerCreateHeaders",
|
||
modelProperties: {
|
||
etag: {
|
||
serializedName: "etag",
|
||
xmlName: "etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
lastModified: {
|
||
serializedName: "last-modified",
|
||
xmlName: "last-modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerCreateExceptionHeaders = {
|
||
serializedName: "Container_createExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerCreateExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerGetPropertiesHeaders = {
|
||
serializedName: "Container_getPropertiesHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerGetPropertiesHeaders",
|
||
modelProperties: {
|
||
metadata: {
|
||
serializedName: "x-ms-meta",
|
||
xmlName: "x-ms-meta",
|
||
type: {
|
||
name: "Dictionary",
|
||
value: { type: { name: "String" } }
|
||
},
|
||
headerCollectionPrefix: "x-ms-meta-"
|
||
},
|
||
etag: {
|
||
serializedName: "etag",
|
||
xmlName: "etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
lastModified: {
|
||
serializedName: "last-modified",
|
||
xmlName: "last-modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
leaseDuration: {
|
||
serializedName: "x-ms-lease-duration",
|
||
xmlName: "x-ms-lease-duration",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["infinite", "fixed"]
|
||
}
|
||
},
|
||
leaseState: {
|
||
serializedName: "x-ms-lease-state",
|
||
xmlName: "x-ms-lease-state",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: [
|
||
"available",
|
||
"leased",
|
||
"expired",
|
||
"breaking",
|
||
"broken"
|
||
]
|
||
}
|
||
},
|
||
leaseStatus: {
|
||
serializedName: "x-ms-lease-status",
|
||
xmlName: "x-ms-lease-status",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["locked", "unlocked"]
|
||
}
|
||
},
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
blobPublicAccess: {
|
||
serializedName: "x-ms-blob-public-access",
|
||
xmlName: "x-ms-blob-public-access",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["container", "blob"]
|
||
}
|
||
},
|
||
hasImmutabilityPolicy: {
|
||
serializedName: "x-ms-has-immutability-policy",
|
||
xmlName: "x-ms-has-immutability-policy",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
hasLegalHold: {
|
||
serializedName: "x-ms-has-legal-hold",
|
||
xmlName: "x-ms-has-legal-hold",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
defaultEncryptionScope: {
|
||
serializedName: "x-ms-default-encryption-scope",
|
||
xmlName: "x-ms-default-encryption-scope",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
denyEncryptionScopeOverride: {
|
||
serializedName: "x-ms-deny-encryption-scope-override",
|
||
xmlName: "x-ms-deny-encryption-scope-override",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
isImmutableStorageWithVersioningEnabled: {
|
||
serializedName: "x-ms-immutable-storage-with-versioning-enabled",
|
||
xmlName: "x-ms-immutable-storage-with-versioning-enabled",
|
||
type: {
|
||
name: "Boolean"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerGetPropertiesExceptionHeaders = {
|
||
serializedName: "Container_getPropertiesExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerGetPropertiesExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerDeleteHeaders = {
|
||
serializedName: "Container_deleteHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerDeleteHeaders",
|
||
modelProperties: {
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerDeleteExceptionHeaders = {
|
||
serializedName: "Container_deleteExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerDeleteExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerSetMetadataHeaders = {
|
||
serializedName: "Container_setMetadataHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerSetMetadataHeaders",
|
||
modelProperties: {
|
||
etag: {
|
||
serializedName: "etag",
|
||
xmlName: "etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
lastModified: {
|
||
serializedName: "last-modified",
|
||
xmlName: "last-modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerSetMetadataExceptionHeaders = {
|
||
serializedName: "Container_setMetadataExceptionHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerSetMetadataExceptionHeaders",
|
||
modelProperties: {
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
const ContainerGetAccessPolicyHeaders = {
|
||
serializedName: "Container_getAccessPolicyHeaders",
|
||
type: {
|
||
name: "Composite",
|
||
className: "ContainerGetAccessPolicyHeaders",
|
||
modelProperties: {
|
||
blobPublicAccess: {
|
||
serializedName: "x-ms-blob-public-access",
|
||
xmlName: "x-ms-blob-public-access",
|
||
type: {
|
||
name: "Enum",
|
||
allowedValues: ["container", "blob"]
|
||
}
|
||
},
|
||
etag: {
|
||
serializedName: "etag",
|
||
xmlName: "etag",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
lastModified: {
|
||
serializedName: "last-modified",
|
||
xmlName: "last-modified",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
clientRequestId: {
|
||
serializedName: "x-ms-client-request-id",
|
||
xmlName: "x-ms-client-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
requestId: {
|
||
serializedName: "x-ms-request-id",
|
||
xmlName: "x-ms-request-id",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
version: {
|
||
serializedName: "x-ms-version",
|
||
xmlName: "x-ms-version",
|
||
type: {
|
||
name: "String"
|
||
}
|
||
},
|
||
date: {
|
||
serializedName: "date",
|
||
xmlName: "date",
|
||
type: {
|
||
name: "DateTimeRfc1123"
|
||
}
|
||
},
|
||
errorCode: {
|
||
serializedName: "x-ms-error-code",
|
||
xmlName: "x-ms-error-code",
|
||
type: {
|
||
name: "String"
|
||