mirror of
https://github.com/oven-sh/setup-bun.git
synced 2025-07-18 04:28:28 +02:00
51889 lines
1.9 MiB
51889 lines
1.9 MiB
import * as $$node_module from "node:module";
|
|
import.meta.require = $$node_module.createRequire(import.meta.url);
|
|
var __create = Object.create;
|
|
var __descs = Object.getOwnPropertyDescriptors;
|
|
var __defProp = Object.defineProperty;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => mod[key],
|
|
enumerable: true
|
|
});
|
|
return to;
|
|
};
|
|
var __toCommonJS = (from) => {
|
|
const moduleCache = __toCommonJS.moduleCache ??= new WeakMap;
|
|
var cached = moduleCache.get(from);
|
|
if (cached)
|
|
return cached;
|
|
var to = __defProp({}, "__esModule", { value: true });
|
|
var desc = { enumerable: false };
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: () => from[key],
|
|
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
});
|
|
}
|
|
moduleCache.set(from, to);
|
|
return to;
|
|
};
|
|
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
|
|
var __require = (id) => {
|
|
return import.meta.require(id);
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: (newValue) => all[name] = () => newValue
|
|
});
|
|
};
|
|
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
|
|
|
|
// node_modules/@actions/core/lib/utils.js
|
|
var require_utils = __commonJS((exports) => {
|
|
var toCommandValue = function(input) {
|
|
if (input === null || input === undefined)
|
|
return "";
|
|
else if (typeof input === "string" || input instanceof String)
|
|
return input;
|
|
return JSON.stringify(input);
|
|
};
|
|
var toCommandProperties = function(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.toCommandValue = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.toCommandProperties = exports.toCommandValue = undefined;
|
|
exports.toCommandValue = toCommandValue;
|
|
exports.toCommandProperties = toCommandProperties;
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/command.js
|
|
var require_command = __commonJS((exports) => {
|
|
var issueCommand = function(command, properties, message) {
|
|
const cmd = new Command(command, properties, message);
|
|
process.stdout.write(cmd.toString() + os.EOL);
|
|
};
|
|
var issue = function(name, message = "") {
|
|
issueCommand(name, {}, message);
|
|
};
|
|
var escapeData = function(s) {
|
|
return utils_1.toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
|
|
};
|
|
var escapeProperty = function(s) {
|
|
return utils_1.toCommandValue(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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.issue = exports.issueCommand = undefined;
|
|
var os = __importStar(__require("os"));
|
|
var utils_1 = require_utils();
|
|
exports.issueCommand = issueCommand;
|
|
exports.issue = issue;
|
|
var CMD_STRING = "::";
|
|
|
|
class Command {
|
|
constructor(command, properties, message) {
|
|
if (!command)
|
|
command = "missing.command";
|
|
this.command = command;
|
|
this.properties = properties;
|
|
this.message = message;
|
|
}
|
|
toString() {
|
|
let cmdStr = CMD_STRING + this.command;
|
|
if (this.properties && Object.keys(this.properties).length > 0) {
|
|
cmdStr += " ";
|
|
let first = true;
|
|
for (const key in this.properties)
|
|
if (this.properties.hasOwnProperty(key)) {
|
|
const val = this.properties[key];
|
|
if (val) {
|
|
if (first)
|
|
first = false;
|
|
else
|
|
cmdStr += ",";
|
|
cmdStr += `${key}=${escapeProperty(val)}`;
|
|
}
|
|
}
|
|
}
|
|
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
|
return cmdStr;
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/rng.js
|
|
import crypto from "crypto";
|
|
function rng() {
|
|
if (poolPtr > rnds8Pool.length - 16) {
|
|
crypto.randomFillSync(rnds8Pool);
|
|
poolPtr = 0;
|
|
}
|
|
return rnds8Pool.slice(poolPtr, poolPtr += 16);
|
|
}
|
|
var rnds8Pool, poolPtr;
|
|
var init_rng = __esm(() => {
|
|
rnds8Pool = new Uint8Array(256);
|
|
poolPtr = rnds8Pool.length;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/regex.js
|
|
var regex_default;
|
|
var init_regex = __esm(() => {
|
|
regex_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;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/validate.js
|
|
var validate, validate_default;
|
|
var init_validate = __esm(() => {
|
|
init_regex();
|
|
validate = function(uuid) {
|
|
return typeof uuid === "string" && regex_default.test(uuid);
|
|
};
|
|
validate_default = validate;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/stringify.js
|
|
var stringify, byteToHex, stringify_default;
|
|
var init_stringify = __esm(() => {
|
|
init_validate();
|
|
stringify = function(arr, offset = 0) {
|
|
const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
|
|
if (!validate_default(uuid))
|
|
throw TypeError("Stringified UUID is invalid");
|
|
return uuid;
|
|
};
|
|
byteToHex = [];
|
|
for (let i = 0;i < 256; ++i)
|
|
byteToHex.push((i + 256).toString(16).substr(1));
|
|
stringify_default = stringify;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/v1.js
|
|
var v1, _nodeId, _clockseq, _lastMSecs, _lastNSecs, v1_default;
|
|
var init_v1 = __esm(() => {
|
|
init_rng();
|
|
init_stringify();
|
|
v1 = function(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;
|
|
if (node == null || clockseq == null) {
|
|
const seedBytes = options.random || (options.rng || rng)();
|
|
if (node == null)
|
|
node = _nodeId = [seedBytes[0] | 1, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
|
|
if (clockseq == null)
|
|
clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 16383;
|
|
}
|
|
let msecs = options.msecs !== undefined ? options.msecs : Date.now();
|
|
let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
|
|
const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 1e4;
|
|
if (dt < 0 && options.clockseq === undefined)
|
|
clockseq = clockseq + 1 & 16383;
|
|
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined)
|
|
nsecs = 0;
|
|
if (nsecs >= 1e4)
|
|
throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
|
|
_lastMSecs = msecs;
|
|
_lastNSecs = nsecs;
|
|
_clockseq = clockseq;
|
|
msecs += 12219292800000;
|
|
const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
|
|
b[i++] = tl >>> 24 & 255;
|
|
b[i++] = tl >>> 16 & 255;
|
|
b[i++] = tl >>> 8 & 255;
|
|
b[i++] = tl & 255;
|
|
const tmh = msecs / 4294967296 * 1e4 & 268435455;
|
|
b[i++] = tmh >>> 8 & 255;
|
|
b[i++] = tmh & 255;
|
|
b[i++] = tmh >>> 24 & 15 | 16;
|
|
b[i++] = tmh >>> 16 & 255;
|
|
b[i++] = clockseq >>> 8 | 128;
|
|
b[i++] = clockseq & 255;
|
|
for (let n = 0;n < 6; ++n)
|
|
b[i + n] = node[n];
|
|
return buf || stringify_default(b);
|
|
};
|
|
_lastMSecs = 0;
|
|
_lastNSecs = 0;
|
|
v1_default = v1;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/parse.js
|
|
var parse, parse_default;
|
|
var init_parse = __esm(() => {
|
|
init_validate();
|
|
parse = function(uuid) {
|
|
if (!validate_default(uuid))
|
|
throw TypeError("Invalid UUID");
|
|
let v;
|
|
const arr = new Uint8Array(16);
|
|
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
|
|
arr[1] = v >>> 16 & 255;
|
|
arr[2] = v >>> 8 & 255;
|
|
arr[3] = v & 255;
|
|
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
|
|
arr[5] = v & 255;
|
|
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
|
|
arr[7] = v & 255;
|
|
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
|
|
arr[9] = v & 255;
|
|
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255;
|
|
arr[11] = v / 4294967296 & 255;
|
|
arr[12] = v >>> 24 & 255;
|
|
arr[13] = v >>> 16 & 255;
|
|
arr[14] = v >>> 8 & 255;
|
|
arr[15] = v & 255;
|
|
return arr;
|
|
};
|
|
parse_default = parse;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/v35.js
|
|
function v35_default(name, version, hashfunc) {
|
|
function generateUUID(value, namespace, buf, offset) {
|
|
if (typeof value === "string")
|
|
value = stringToBytes(value);
|
|
if (typeof namespace === "string")
|
|
namespace = parse_default(namespace);
|
|
if (namespace.length !== 16)
|
|
throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
|
|
let bytes = new Uint8Array(16 + value.length);
|
|
bytes.set(namespace);
|
|
bytes.set(value, namespace.length);
|
|
bytes = hashfunc(bytes);
|
|
bytes[6] = bytes[6] & 15 | version;
|
|
bytes[8] = bytes[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
for (let i = 0;i < 16; ++i)
|
|
buf[offset + i] = bytes[i];
|
|
return buf;
|
|
}
|
|
return stringify_default(bytes);
|
|
}
|
|
try {
|
|
generateUUID.name = name;
|
|
} catch (err) {
|
|
}
|
|
generateUUID.DNS = DNS;
|
|
generateUUID.URL = URL2;
|
|
return generateUUID;
|
|
}
|
|
var stringToBytes, DNS, URL2;
|
|
var init_v35 = __esm(() => {
|
|
init_stringify();
|
|
init_parse();
|
|
stringToBytes = function(str) {
|
|
str = unescape(encodeURIComponent(str));
|
|
const bytes = [];
|
|
for (let i = 0;i < str.length; ++i)
|
|
bytes.push(str.charCodeAt(i));
|
|
return bytes;
|
|
};
|
|
DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
|
|
URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/md5.js
|
|
import crypto2 from "crypto";
|
|
var md5, md5_default;
|
|
var init_md5 = __esm(() => {
|
|
md5 = function(bytes) {
|
|
if (Array.isArray(bytes))
|
|
bytes = Buffer.from(bytes);
|
|
else if (typeof bytes === "string")
|
|
bytes = Buffer.from(bytes, "utf8");
|
|
return crypto2.createHash("md5").update(bytes).digest();
|
|
};
|
|
md5_default = md5;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/v3.js
|
|
var v3, v3_default;
|
|
var init_v3 = __esm(() => {
|
|
init_v35();
|
|
init_md5();
|
|
v3 = v35_default("v3", 48, md5_default);
|
|
v3_default = v3;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/v4.js
|
|
var v4, v4_default;
|
|
var init_v4 = __esm(() => {
|
|
init_rng();
|
|
init_stringify();
|
|
v4 = function(options, buf, offset) {
|
|
options = options || {};
|
|
const rnds = options.random || (options.rng || rng)();
|
|
rnds[6] = rnds[6] & 15 | 64;
|
|
rnds[8] = rnds[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
for (let i = 0;i < 16; ++i)
|
|
buf[offset + i] = rnds[i];
|
|
return buf;
|
|
}
|
|
return stringify_default(rnds);
|
|
};
|
|
v4_default = v4;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/sha1.js
|
|
import crypto3 from "crypto";
|
|
var sha1, sha1_default;
|
|
var init_sha1 = __esm(() => {
|
|
sha1 = function(bytes) {
|
|
if (Array.isArray(bytes))
|
|
bytes = Buffer.from(bytes);
|
|
else if (typeof bytes === "string")
|
|
bytes = Buffer.from(bytes, "utf8");
|
|
return crypto3.createHash("sha1").update(bytes).digest();
|
|
};
|
|
sha1_default = sha1;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/v5.js
|
|
var v5, v5_default;
|
|
var init_v5 = __esm(() => {
|
|
init_v35();
|
|
init_sha1();
|
|
v5 = v35_default("v5", 80, sha1_default);
|
|
v5_default = v5;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/nil.js
|
|
var nil_default;
|
|
var init_nil = __esm(() => {
|
|
nil_default = "00000000-0000-0000-0000-000000000000";
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/version.js
|
|
var version, version_default;
|
|
var init_version = __esm(() => {
|
|
init_validate();
|
|
version = function(uuid) {
|
|
if (!validate_default(uuid))
|
|
throw TypeError("Invalid UUID");
|
|
return parseInt(uuid.substr(14, 1), 16);
|
|
};
|
|
version_default = version;
|
|
});
|
|
|
|
// node_modules/@actions/core/node_modules/uuid/dist/esm-node/index.js
|
|
var exports_esm_node = {};
|
|
__export(exports_esm_node, {
|
|
version: () => {
|
|
{
|
|
return version_default;
|
|
}
|
|
},
|
|
validate: () => {
|
|
{
|
|
return validate_default;
|
|
}
|
|
},
|
|
v5: () => {
|
|
{
|
|
return v5_default;
|
|
}
|
|
},
|
|
v4: () => {
|
|
{
|
|
return v4_default;
|
|
}
|
|
},
|
|
v3: () => {
|
|
{
|
|
return v3_default;
|
|
}
|
|
},
|
|
v1: () => {
|
|
{
|
|
return v1_default;
|
|
}
|
|
},
|
|
stringify: () => {
|
|
{
|
|
return stringify_default;
|
|
}
|
|
},
|
|
parse: () => {
|
|
{
|
|
return parse_default;
|
|
}
|
|
},
|
|
NIL: () => {
|
|
{
|
|
return nil_default;
|
|
}
|
|
}
|
|
});
|
|
var init_esm_node = __esm(() => {
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/file-command.js
|
|
var require_file_command = __commonJS((exports) => {
|
|
var issueFileCommand = function(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"
|
|
});
|
|
};
|
|
var prepareKeyValueMessage = function(key, value) {
|
|
const delimiter = `ghadelimiter_${uuid_1.v4()}`;
|
|
const convertedValue = utils_1.toCommandValue(value);
|
|
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}`;
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = undefined;
|
|
var fs = __importStar(__require("fs"));
|
|
var os = __importStar(__require("os"));
|
|
var uuid_1 = (init_esm_node(), __toCommonJS(exports_esm_node));
|
|
var utils_1 = require_utils();
|
|
exports.issueFileCommand = issueFileCommand;
|
|
exports.prepareKeyValueMessage = prepareKeyValueMessage;
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/proxy.js
|
|
var require_proxy = __commonJS((exports) => {
|
|
var getProxyUrl = function(reqUrl) {
|
|
const usingSsl = reqUrl.protocol === "https:";
|
|
if (checkBypass(reqUrl))
|
|
return;
|
|
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;
|
|
};
|
|
var checkBypass = function(reqUrl) {
|
|
if (!reqUrl.hostname)
|
|
return false;
|
|
const reqHost = reqUrl.hostname;
|
|
if (isLoopbackAddress(reqHost))
|
|
return true;
|
|
const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || "";
|
|
if (!noProxy)
|
|
return false;
|
|
let reqPort;
|
|
if (reqUrl.port)
|
|
reqPort = Number(reqUrl.port);
|
|
else if (reqUrl.protocol === "http:")
|
|
reqPort = 80;
|
|
else if (reqUrl.protocol === "https:")
|
|
reqPort = 443;
|
|
const upperReqHosts = [reqUrl.hostname.toUpperCase()];
|
|
if (typeof reqPort === "number")
|
|
upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
|
|
for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x))
|
|
if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`)))
|
|
return true;
|
|
return false;
|
|
};
|
|
var isLoopbackAddress = function(host) {
|
|
const hostLower = host.toLowerCase();
|
|
return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]");
|
|
};
|
|
exports.getProxyUrl = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.checkBypass = exports.getProxyUrl = undefined;
|
|
exports.getProxyUrl = getProxyUrl;
|
|
exports.checkBypass = checkBypass;
|
|
});
|
|
|
|
// node_modules/tunnel/lib/tunnel.js
|
|
var require_tunnel = __commonJS((exports) => {
|
|
var httpOverHttp = function(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http.request;
|
|
return agent;
|
|
};
|
|
var httpsOverHttp = function(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = http.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
};
|
|
var httpOverHttps = function(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https.request;
|
|
return agent;
|
|
};
|
|
var httpsOverHttps = function(options) {
|
|
var agent = new TunnelingAgent(options);
|
|
agent.request = https.request;
|
|
agent.createSocket = createSecureSocket;
|
|
agent.defaultPort = 443;
|
|
return agent;
|
|
};
|
|
var TunnelingAgent = function(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 options2 = toOptions(host, port, localAddress);
|
|
for (var i = 0, len = self.requests.length;i < len; ++i) {
|
|
var pending = self.requests[i];
|
|
if (pending.host === options2.host && pending.port === options2.port) {
|
|
self.requests.splice(i, 1);
|
|
pending.request.onSocket(socket);
|
|
return;
|
|
}
|
|
}
|
|
socket.destroy();
|
|
self.removeSocket(socket);
|
|
});
|
|
};
|
|
var createSecureSocket = function(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,
|
|
servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host
|
|
});
|
|
var secureSocket = tls.connect(0, tlsOptions);
|
|
self.sockets[self.sockets.indexOf(socket)] = secureSocket;
|
|
cb(secureSocket);
|
|
});
|
|
};
|
|
var toOptions = function(host, port, localAddress) {
|
|
if (typeof host === "string")
|
|
return {
|
|
host,
|
|
port,
|
|
localAddress
|
|
};
|
|
return host;
|
|
};
|
|
var mergeOptions = function(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 net = __require("net");
|
|
var tls = __require("tls");
|
|
var http = __require("http");
|
|
var https = __require("https");
|
|
var events = __require("events");
|
|
var assert = __require("assert");
|
|
var util = __require("util");
|
|
exports.httpOverHttp = httpOverHttp;
|
|
exports.httpsOverHttp = httpsOverHttp;
|
|
exports.httpOverHttps = httpOverHttps;
|
|
exports.httpsOverHttps = httpsOverHttps;
|
|
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) {
|
|
self.requests.push(options);
|
|
return;
|
|
}
|
|
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;
|
|
connectReq.once("response", onResponse);
|
|
connectReq.once("upgrade", onUpgrade);
|
|
connectReq.once("connect", onConnect);
|
|
connectReq.once("error", onError);
|
|
connectReq.end();
|
|
function onResponse(res) {
|
|
res.upgrade = true;
|
|
}
|
|
function onUpgrade(res, socket, head) {
|
|
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)
|
|
this.createSocket(pending, function(socket2) {
|
|
pending.request.onSocket(socket2);
|
|
});
|
|
};
|
|
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;
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/index.js
|
|
var require_lib = __commonJS((exports) => {
|
|
var getProxyUrl = function(serverUrl) {
|
|
const proxyUrl = pm.getProxyUrl(new URL(serverUrl));
|
|
return proxyUrl ? proxyUrl.href : "";
|
|
};
|
|
var isHttps = function(requestUrl) {
|
|
const parsedUrl = new URL(requestUrl);
|
|
return parsedUrl.protocol === "https:";
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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.HttpClient = exports.isHttps = exports.HttpClientResponse = exports.HttpClientError = exports.getProxyUrl = exports.MediaTypes = exports.Headers = exports.HttpCodes = undefined;
|
|
var http = __importStar(__require("http"));
|
|
var https = __importStar(__require("https"));
|
|
var pm = __importStar(require_proxy());
|
|
var tunnel = __importStar(require_tunnel());
|
|
var HttpCodes;
|
|
(function(HttpCodes2) {
|
|
HttpCodes2[HttpCodes2["OK"] = 200] = "OK";
|
|
HttpCodes2[HttpCodes2["MultipleChoices"] = 300] = "MultipleChoices";
|
|
HttpCodes2[HttpCodes2["MovedPermanently"] = 301] = "MovedPermanently";
|
|
HttpCodes2[HttpCodes2["ResourceMoved"] = 302] = "ResourceMoved";
|
|
HttpCodes2[HttpCodes2["SeeOther"] = 303] = "SeeOther";
|
|
HttpCodes2[HttpCodes2["NotModified"] = 304] = "NotModified";
|
|
HttpCodes2[HttpCodes2["UseProxy"] = 305] = "UseProxy";
|
|
HttpCodes2[HttpCodes2["SwitchProxy"] = 306] = "SwitchProxy";
|
|
HttpCodes2[HttpCodes2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
|
|
HttpCodes2[HttpCodes2["PermanentRedirect"] = 308] = "PermanentRedirect";
|
|
HttpCodes2[HttpCodes2["BadRequest"] = 400] = "BadRequest";
|
|
HttpCodes2[HttpCodes2["Unauthorized"] = 401] = "Unauthorized";
|
|
HttpCodes2[HttpCodes2["PaymentRequired"] = 402] = "PaymentRequired";
|
|
HttpCodes2[HttpCodes2["Forbidden"] = 403] = "Forbidden";
|
|
HttpCodes2[HttpCodes2["NotFound"] = 404] = "NotFound";
|
|
HttpCodes2[HttpCodes2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
|
|
HttpCodes2[HttpCodes2["NotAcceptable"] = 406] = "NotAcceptable";
|
|
HttpCodes2[HttpCodes2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
|
|
HttpCodes2[HttpCodes2["RequestTimeout"] = 408] = "RequestTimeout";
|
|
HttpCodes2[HttpCodes2["Conflict"] = 409] = "Conflict";
|
|
HttpCodes2[HttpCodes2["Gone"] = 410] = "Gone";
|
|
HttpCodes2[HttpCodes2["TooManyRequests"] = 429] = "TooManyRequests";
|
|
HttpCodes2[HttpCodes2["InternalServerError"] = 500] = "InternalServerError";
|
|
HttpCodes2[HttpCodes2["NotImplemented"] = 501] = "NotImplemented";
|
|
HttpCodes2[HttpCodes2["BadGateway"] = 502] = "BadGateway";
|
|
HttpCodes2[HttpCodes2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
|
|
HttpCodes2[HttpCodes2["GatewayTimeout"] = 504] = "GatewayTimeout";
|
|
})(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {}));
|
|
var Headers;
|
|
(function(Headers2) {
|
|
Headers2["Accept"] = "accept";
|
|
Headers2["ContentType"] = "content-type";
|
|
})(Headers = exports.Headers || (exports.Headers = {}));
|
|
var MediaTypes;
|
|
(function(MediaTypes2) {
|
|
MediaTypes2["ApplicationJson"] = "application/json";
|
|
})(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {}));
|
|
exports.getProxyUrl = getProxyUrl;
|
|
var HttpRedirectCodes = [
|
|
HttpCodes.MovedPermanently,
|
|
HttpCodes.ResourceMoved,
|
|
HttpCodes.SeeOther,
|
|
HttpCodes.TemporaryRedirect,
|
|
HttpCodes.PermanentRedirect
|
|
];
|
|
var HttpResponseRetryCodes = [
|
|
HttpCodes.BadGateway,
|
|
HttpCodes.ServiceUnavailable,
|
|
HttpCodes.GatewayTimeout
|
|
];
|
|
var RetryableHttpVerbs = ["OPTIONS", "GET", "DELETE", "HEAD"];
|
|
var ExponentialBackoffCeiling = 10;
|
|
var ExponentialBackoffTimeSlice = 5;
|
|
|
|
class HttpClientError extends Error {
|
|
constructor(message, statusCode) {
|
|
super(message);
|
|
this.name = "HttpClientError";
|
|
this.statusCode = statusCode;
|
|
Object.setPrototypeOf(this, HttpClientError.prototype);
|
|
}
|
|
}
|
|
exports.HttpClientError = HttpClientError;
|
|
|
|
class HttpClientResponse {
|
|
constructor(message) {
|
|
this.message = message;
|
|
}
|
|
readBody() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return new Promise((resolve) => __awaiter(this, undefined, undefined, function* () {
|
|
let output = Buffer.alloc(0);
|
|
this.message.on("data", (chunk) => {
|
|
output = Buffer.concat([output, chunk]);
|
|
});
|
|
this.message.on("end", () => {
|
|
resolve(output.toString());
|
|
});
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
exports.HttpClientResponse = HttpClientResponse;
|
|
exports.isHttps = isHttps;
|
|
|
|
class HttpClient {
|
|
constructor(userAgent, handlers, requestOptions) {
|
|
this._ignoreSslError = false;
|
|
this._allowRedirects = true;
|
|
this._allowRedirectDowngrade = false;
|
|
this._maxRedirects = 50;
|
|
this._allowRetries = false;
|
|
this._maxRetries = 1;
|
|
this._keepAlive = false;
|
|
this._disposed = false;
|
|
this.userAgent = userAgent;
|
|
this.handlers = handlers || [];
|
|
this.requestOptions = requestOptions;
|
|
if (requestOptions) {
|
|
if (requestOptions.ignoreSslError != null)
|
|
this._ignoreSslError = requestOptions.ignoreSslError;
|
|
this._socketTimeout = requestOptions.socketTimeout;
|
|
if (requestOptions.allowRedirects != null)
|
|
this._allowRedirects = requestOptions.allowRedirects;
|
|
if (requestOptions.allowRedirectDowngrade != null)
|
|
this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
|
|
if (requestOptions.maxRedirects != null)
|
|
this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
|
|
if (requestOptions.keepAlive != null)
|
|
this._keepAlive = requestOptions.keepAlive;
|
|
if (requestOptions.allowRetries != null)
|
|
this._allowRetries = requestOptions.allowRetries;
|
|
if (requestOptions.maxRetries != null)
|
|
this._maxRetries = requestOptions.maxRetries;
|
|
}
|
|
}
|
|
options(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("OPTIONS", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
get(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("GET", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
del(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("DELETE", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
post(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("POST", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
patch(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("PATCH", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
put(requestUrl, data, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("PUT", requestUrl, data, additionalHeaders || {});
|
|
});
|
|
}
|
|
head(requestUrl, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request("HEAD", requestUrl, null, additionalHeaders || {});
|
|
});
|
|
}
|
|
sendStream(verb, requestUrl, stream, additionalHeaders) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.request(verb, requestUrl, stream, additionalHeaders);
|
|
});
|
|
}
|
|
getJson(requestUrl, additionalHeaders = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
const res = yield this.get(requestUrl, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
postJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.post(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
putJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.put(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
patchJson(requestUrl, obj, additionalHeaders = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const data = JSON.stringify(obj, null, 2);
|
|
additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
|
|
additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
|
|
const res = yield this.patch(requestUrl, data, additionalHeaders);
|
|
return this._processResponse(res, this.requestOptions);
|
|
});
|
|
}
|
|
request(verb, requestUrl, data, headers) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (this._disposed)
|
|
throw new Error("Client has already been disposed.");
|
|
const parsedUrl = new URL(requestUrl);
|
|
let info = this._prepareRequest(verb, parsedUrl, headers);
|
|
const maxTries = this._allowRetries && RetryableHttpVerbs.includes(verb) ? this._maxRetries + 1 : 1;
|
|
let numTries = 0;
|
|
let response;
|
|
do {
|
|
response = yield this.requestRaw(info, data);
|
|
if (response && response.message && response.message.statusCode === HttpCodes.Unauthorized) {
|
|
let authenticationHandler;
|
|
for (const handler of this.handlers)
|
|
if (handler.canHandleAuthentication(response)) {
|
|
authenticationHandler = handler;
|
|
break;
|
|
}
|
|
if (authenticationHandler)
|
|
return authenticationHandler.handleAuthentication(this, info, data);
|
|
else
|
|
return response;
|
|
}
|
|
let redirectsRemaining = this._maxRedirects;
|
|
while (response.message.statusCode && HttpRedirectCodes.includes(response.message.statusCode) && this._allowRedirects && redirectsRemaining > 0) {
|
|
const redirectUrl = response.message.headers["location"];
|
|
if (!redirectUrl)
|
|
break;
|
|
const parsedRedirectUrl = new URL(redirectUrl);
|
|
if (parsedUrl.protocol === "https:" && parsedUrl.protocol !== parsedRedirectUrl.protocol && !this._allowRedirectDowngrade)
|
|
throw new Error("Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.");
|
|
yield response.readBody();
|
|
if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
|
|
for (const header in headers)
|
|
if (header.toLowerCase() === "authorization")
|
|
delete headers[header];
|
|
}
|
|
info = this._prepareRequest(verb, parsedRedirectUrl, headers);
|
|
response = yield this.requestRaw(info, data);
|
|
redirectsRemaining--;
|
|
}
|
|
if (!response.message.statusCode || !HttpResponseRetryCodes.includes(response.message.statusCode))
|
|
return response;
|
|
numTries += 1;
|
|
if (numTries < maxTries) {
|
|
yield response.readBody();
|
|
yield this._performExponentialBackoff(numTries);
|
|
}
|
|
} while (numTries < maxTries);
|
|
return response;
|
|
});
|
|
}
|
|
dispose() {
|
|
if (this._agent)
|
|
this._agent.destroy();
|
|
this._disposed = true;
|
|
}
|
|
requestRaw(info, data) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return new Promise((resolve, reject) => {
|
|
function callbackForResult(err, res) {
|
|
if (err)
|
|
reject(err);
|
|
else if (!res)
|
|
reject(new Error("Unknown error"));
|
|
else
|
|
resolve(res);
|
|
}
|
|
this.requestRawWithCallback(info, data, callbackForResult);
|
|
});
|
|
});
|
|
}
|
|
requestRawWithCallback(info, data, onResult) {
|
|
if (typeof data === "string") {
|
|
if (!info.options.headers)
|
|
info.options.headers = {};
|
|
info.options.headers["Content-Length"] = Buffer.byteLength(data, "utf8");
|
|
}
|
|
let callbackCalled = false;
|
|
function handleResult(err, res) {
|
|
if (!callbackCalled) {
|
|
callbackCalled = true;
|
|
onResult(err, res);
|
|
}
|
|
}
|
|
const req = info.httpModule.request(info.options, (msg) => {
|
|
const res = new HttpClientResponse(msg);
|
|
handleResult(undefined, res);
|
|
});
|
|
let socket;
|
|
req.on("socket", (sock) => {
|
|
socket = sock;
|
|
});
|
|
req.setTimeout(this._socketTimeout || 3 * 60000, () => {
|
|
if (socket)
|
|
socket.end();
|
|
handleResult(new Error(`Request timeout: ${info.options.path}`));
|
|
});
|
|
req.on("error", function(err) {
|
|
handleResult(err);
|
|
});
|
|
if (data && typeof data === "string")
|
|
req.write(data, "utf8");
|
|
if (data && typeof data !== "string") {
|
|
data.on("close", function() {
|
|
req.end();
|
|
});
|
|
data.pipe(req);
|
|
} else
|
|
req.end();
|
|
}
|
|
getAgent(serverUrl) {
|
|
const parsedUrl = new URL(serverUrl);
|
|
return this._getAgent(parsedUrl);
|
|
}
|
|
_prepareRequest(method, requestUrl, headers) {
|
|
const info = {};
|
|
info.parsedUrl = requestUrl;
|
|
const usingSsl = info.parsedUrl.protocol === "https:";
|
|
info.httpModule = usingSsl ? https : http;
|
|
const defaultPort = usingSsl ? 443 : 80;
|
|
info.options = {};
|
|
info.options.host = info.parsedUrl.hostname;
|
|
info.options.port = info.parsedUrl.port ? parseInt(info.parsedUrl.port) : defaultPort;
|
|
info.options.path = (info.parsedUrl.pathname || "") + (info.parsedUrl.search || "");
|
|
info.options.method = method;
|
|
info.options.headers = this._mergeHeaders(headers);
|
|
if (this.userAgent != null)
|
|
info.options.headers["user-agent"] = this.userAgent;
|
|
info.options.agent = this._getAgent(info.parsedUrl);
|
|
if (this.handlers)
|
|
for (const handler of this.handlers)
|
|
handler.prepareRequest(info.options);
|
|
return info;
|
|
}
|
|
_mergeHeaders(headers) {
|
|
if (this.requestOptions && this.requestOptions.headers)
|
|
return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers || {}));
|
|
return lowercaseKeys(headers || {});
|
|
}
|
|
_getExistingOrDefaultHeader(additionalHeaders, header, _default) {
|
|
let clientHeader;
|
|
if (this.requestOptions && this.requestOptions.headers)
|
|
clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
|
|
return additionalHeaders[header] || clientHeader || _default;
|
|
}
|
|
_getAgent(parsedUrl) {
|
|
let agent;
|
|
const proxyUrl = pm.getProxyUrl(parsedUrl);
|
|
const useProxy = proxyUrl && proxyUrl.hostname;
|
|
if (this._keepAlive && useProxy)
|
|
agent = this._proxyAgent;
|
|
if (this._keepAlive && !useProxy)
|
|
agent = this._agent;
|
|
if (agent)
|
|
return agent;
|
|
const usingSsl = parsedUrl.protocol === "https:";
|
|
let maxSockets = 100;
|
|
if (this.requestOptions)
|
|
maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
|
|
if (proxyUrl && proxyUrl.hostname) {
|
|
const agentOptions = {
|
|
maxSockets,
|
|
keepAlive: this._keepAlive,
|
|
proxy: Object.assign(Object.assign({}, (proxyUrl.username || proxyUrl.password) && {
|
|
proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
|
|
}), { host: proxyUrl.hostname, port: proxyUrl.port })
|
|
};
|
|
let tunnelAgent;
|
|
const overHttps = proxyUrl.protocol === "https:";
|
|
if (usingSsl)
|
|
tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
|
|
else
|
|
tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
|
|
agent = tunnelAgent(agentOptions);
|
|
this._proxyAgent = agent;
|
|
}
|
|
if (this._keepAlive && !agent) {
|
|
const options = { keepAlive: this._keepAlive, maxSockets };
|
|
agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
|
|
this._agent = agent;
|
|
}
|
|
if (!agent)
|
|
agent = usingSsl ? https.globalAgent : http.globalAgent;
|
|
if (usingSsl && this._ignoreSslError)
|
|
agent.options = Object.assign(agent.options || {}, {
|
|
rejectUnauthorized: false
|
|
});
|
|
return agent;
|
|
}
|
|
_performExponentialBackoff(retryNumber) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
|
|
const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
|
|
return new Promise((resolve) => setTimeout(() => resolve(), ms));
|
|
});
|
|
}
|
|
_processResponse(res, options) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return new Promise((resolve, reject) => __awaiter(this, undefined, undefined, function* () {
|
|
const statusCode = res.message.statusCode || 0;
|
|
const response = {
|
|
statusCode,
|
|
result: null,
|
|
headers: {}
|
|
};
|
|
if (statusCode === HttpCodes.NotFound)
|
|
resolve(response);
|
|
function dateTimeDeserializer(key, value) {
|
|
if (typeof value === "string") {
|
|
const a = new Date(value);
|
|
if (!isNaN(a.valueOf()))
|
|
return a;
|
|
}
|
|
return value;
|
|
}
|
|
let obj;
|
|
let contents;
|
|
try {
|
|
contents = yield res.readBody();
|
|
if (contents && contents.length > 0) {
|
|
if (options && options.deserializeDates)
|
|
obj = JSON.parse(contents, dateTimeDeserializer);
|
|
else
|
|
obj = JSON.parse(contents);
|
|
response.result = obj;
|
|
}
|
|
response.headers = res.message.headers;
|
|
} catch (err) {
|
|
}
|
|
if (statusCode > 299) {
|
|
let msg;
|
|
if (obj && obj.message)
|
|
msg = obj.message;
|
|
else if (contents && contents.length > 0)
|
|
msg = contents;
|
|
else
|
|
msg = `Failed request: (${statusCode})`;
|
|
const err = new HttpClientError(msg, statusCode);
|
|
err.result = response.result;
|
|
reject(err);
|
|
} else
|
|
resolve(response);
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
exports.HttpClient = HttpClient;
|
|
var lowercaseKeys = (obj) => Object.keys(obj).reduce((c, k) => (c[k.toLowerCase()] = obj[k], c), {});
|
|
});
|
|
|
|
// node_modules/@actions/http-client/lib/auth.js
|
|
var require_auth = __commonJS((exports) => {
|
|
var __awaiter = exports && exports.__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.PersonalAccessTokenCredentialHandler = exports.BearerCredentialHandler = exports.BasicCredentialHandler = undefined;
|
|
|
|
class BasicCredentialHandler {
|
|
constructor(username, password) {
|
|
this.username = username;
|
|
this.password = password;
|
|
}
|
|
prepareRequest(options) {
|
|
if (!options.headers)
|
|
throw Error("The request has no headers");
|
|
options.headers["Authorization"] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString("base64")}`;
|
|
}
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
}
|
|
exports.BasicCredentialHandler = BasicCredentialHandler;
|
|
|
|
class BearerCredentialHandler {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
prepareRequest(options) {
|
|
if (!options.headers)
|
|
throw Error("The request has no headers");
|
|
options.headers["Authorization"] = `Bearer ${this.token}`;
|
|
}
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
}
|
|
exports.BearerCredentialHandler = BearerCredentialHandler;
|
|
|
|
class PersonalAccessTokenCredentialHandler {
|
|
constructor(token) {
|
|
this.token = token;
|
|
}
|
|
prepareRequest(options) {
|
|
if (!options.headers)
|
|
throw Error("The request has no headers");
|
|
options.headers["Authorization"] = `Basic ${Buffer.from(`PAT:${this.token}`).toString("base64")}`;
|
|
}
|
|
canHandleAuthentication() {
|
|
return false;
|
|
}
|
|
handleAuthentication() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
throw new Error("not implemented");
|
|
});
|
|
}
|
|
}
|
|
exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/oidc-utils.js
|
|
var require_oidc_utils = __commonJS((exports) => {
|
|
var __awaiter = exports && exports.__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.OidcClient = undefined;
|
|
var http_client_1 = require_lib();
|
|
var auth_1 = require_auth();
|
|
var core_1 = require_core();
|
|
|
|
class OidcClient {
|
|
static createHttpClient(allowRetry = true, maxRetry = 10) {
|
|
const requestOptions = {
|
|
allowRetries: allowRetry,
|
|
maxRetries: maxRetry
|
|
};
|
|
return new http_client_1.HttpClient("actions/oidc-client", [new auth_1.BearerCredentialHandler(OidcClient.getRequestToken())], requestOptions);
|
|
}
|
|
static getRequestToken() {
|
|
const token = process.env["ACTIONS_ID_TOKEN_REQUEST_TOKEN"];
|
|
if (!token)
|
|
throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_TOKEN env variable");
|
|
return token;
|
|
}
|
|
static getIDTokenUrl() {
|
|
const runtimeUrl = process.env["ACTIONS_ID_TOKEN_REQUEST_URL"];
|
|
if (!runtimeUrl)
|
|
throw new Error("Unable to get ACTIONS_ID_TOKEN_REQUEST_URL env variable");
|
|
return runtimeUrl;
|
|
}
|
|
static getCall(id_token_url) {
|
|
var _a;
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const httpclient = OidcClient.createHttpClient();
|
|
const res = yield httpclient.getJson(id_token_url).catch((error) => {
|
|
throw new Error(`Failed to get ID Token. \n
|
|
Error Code : ${error.statusCode}\n
|
|
Error Message: ${error.result.message}`);
|
|
});
|
|
const id_token = (_a = res.result) === null || _a === undefined ? undefined : _a.value;
|
|
if (!id_token)
|
|
throw new Error("Response json body do not have ID Token field");
|
|
return id_token;
|
|
});
|
|
}
|
|
static getIDToken(audience) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
try {
|
|
let id_token_url = OidcClient.getIDTokenUrl();
|
|
if (audience) {
|
|
const encodedAudience = encodeURIComponent(audience);
|
|
id_token_url = `${id_token_url}&audience=${encodedAudience}`;
|
|
}
|
|
core_1.debug(`ID token url is ${id_token_url}`);
|
|
const id_token = yield OidcClient.getCall(id_token_url);
|
|
core_1.setSecret(id_token);
|
|
return id_token;
|
|
} catch (error) {
|
|
throw new Error(`Error message: ${error.message}`);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
exports.OidcClient = OidcClient;
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/summary.js
|
|
var require_summary = __commonJS((exports) => {
|
|
var __awaiter = exports && exports.__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.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = undefined;
|
|
var os_1 = __require("os");
|
|
var fs_1 = __require("fs");
|
|
var { access, appendFile, writeFile } = fs_1.promises;
|
|
exports.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY";
|
|
exports.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary";
|
|
|
|
class Summary {
|
|
constructor() {
|
|
this._buffer = "";
|
|
}
|
|
filePath() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (this._filePath)
|
|
return this._filePath;
|
|
const pathFromEnv = process.env[exports.SUMMARY_ENV_VAR];
|
|
if (!pathFromEnv)
|
|
throw new Error(`Unable to find environment variable for \$${exports.SUMMARY_ENV_VAR}. Check if your runtime environment supports job summaries.`);
|
|
try {
|
|
yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK);
|
|
} catch (_a) {
|
|
throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
|
|
}
|
|
this._filePath = pathFromEnv;
|
|
return this._filePath;
|
|
});
|
|
}
|
|
wrap(tag, content, attrs = {}) {
|
|
const htmlAttrs = Object.entries(attrs).map(([key, value]) => ` ${key}="${value}"`).join("");
|
|
if (!content)
|
|
return `<${tag}${htmlAttrs}>`;
|
|
return `<${tag}${htmlAttrs}>${content}</${tag}>`;
|
|
}
|
|
write(options) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const overwrite = !!(options === null || options === undefined ? undefined : options.overwrite);
|
|
const filePath = yield this.filePath();
|
|
const writeFunc = overwrite ? writeFile : appendFile;
|
|
yield writeFunc(filePath, this._buffer, { encoding: "utf8" });
|
|
return this.emptyBuffer();
|
|
});
|
|
}
|
|
clear() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return this.emptyBuffer().write({ overwrite: true });
|
|
});
|
|
}
|
|
stringify() {
|
|
return this._buffer;
|
|
}
|
|
isEmptyBuffer() {
|
|
return this._buffer.length === 0;
|
|
}
|
|
emptyBuffer() {
|
|
this._buffer = "";
|
|
return this;
|
|
}
|
|
addRaw(text, addEOL = false) {
|
|
this._buffer += text;
|
|
return addEOL ? this.addEOL() : this;
|
|
}
|
|
addEOL() {
|
|
return this.addRaw(os_1.EOL);
|
|
}
|
|
addCodeBlock(code, lang) {
|
|
const attrs = Object.assign({}, lang && { lang });
|
|
const element = this.wrap("pre", this.wrap("code", code), attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addList(items, ordered = false) {
|
|
const tag = ordered ? "ol" : "ul";
|
|
const listItems = items.map((item) => this.wrap("li", item)).join("");
|
|
const element = this.wrap(tag, listItems);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addTable(rows) {
|
|
const tableBody = rows.map((row) => {
|
|
const cells = row.map((cell) => {
|
|
if (typeof cell === "string")
|
|
return this.wrap("td", cell);
|
|
const { header, data, colspan, rowspan } = cell;
|
|
const tag = header ? "th" : "td";
|
|
const attrs = Object.assign(Object.assign({}, colspan && { colspan }), rowspan && { rowspan });
|
|
return this.wrap(tag, data, attrs);
|
|
}).join("");
|
|
return this.wrap("tr", cells);
|
|
}).join("");
|
|
const element = this.wrap("table", tableBody);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addDetails(label, content) {
|
|
const element = this.wrap("details", this.wrap("summary", label) + content);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addImage(src, alt, options) {
|
|
const { width, height } = options || {};
|
|
const attrs = Object.assign(Object.assign({}, width && { width }), height && { height });
|
|
const element = this.wrap("img", null, Object.assign({ src, alt }, attrs));
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addHeading(text, level) {
|
|
const tag = `h${level}`;
|
|
const allowedTag = ["h1", "h2", "h3", "h4", "h5", "h6"].includes(tag) ? tag : "h1";
|
|
const element = this.wrap(allowedTag, text);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addSeparator() {
|
|
const element = this.wrap("hr", null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addBreak() {
|
|
const element = this.wrap("br", null);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addQuote(text, cite) {
|
|
const attrs = Object.assign({}, cite && { cite });
|
|
const element = this.wrap("blockquote", text, attrs);
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
addLink(text, href) {
|
|
const element = this.wrap("a", text, { href });
|
|
return this.addRaw(element).addEOL();
|
|
}
|
|
}
|
|
var _summary = new Summary;
|
|
exports.markdownSummary = _summary;
|
|
exports.summary = _summary;
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/path-utils.js
|
|
var require_path_utils = __commonJS((exports) => {
|
|
var toPosixPath = function(pth) {
|
|
return pth.replace(/[\\]/g, "/");
|
|
};
|
|
var toWin32Path = function(pth) {
|
|
return pth.replace(/[/]/g, "\\");
|
|
};
|
|
var toPlatformPath = function(pth) {
|
|
return pth.replace(/[/\\]/g, path.sep);
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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.toPlatformPath = exports.toWin32Path = exports.toPosixPath = undefined;
|
|
var path = __importStar(__require("path"));
|
|
exports.toPosixPath = toPosixPath;
|
|
exports.toWin32Path = toWin32Path;
|
|
exports.toPlatformPath = toPlatformPath;
|
|
});
|
|
|
|
// node_modules/@actions/core/lib/core.js
|
|
var require_core = __commonJS((exports) => {
|
|
var exportVariable = function(name, val) {
|
|
const convertedVal = utils_1.toCommandValue(val);
|
|
process.env[name] = convertedVal;
|
|
const filePath = process.env["GITHUB_ENV"] || "";
|
|
if (filePath)
|
|
return file_command_1.issueFileCommand("ENV", file_command_1.prepareKeyValueMessage(name, val));
|
|
command_1.issueCommand("set-env", { name }, convertedVal);
|
|
};
|
|
var setSecret = function(secret) {
|
|
command_1.issueCommand("add-mask", {}, secret);
|
|
};
|
|
var addPath = function(inputPath) {
|
|
const filePath = process.env["GITHUB_PATH"] || "";
|
|
if (filePath)
|
|
file_command_1.issueFileCommand("PATH", inputPath);
|
|
else
|
|
command_1.issueCommand("add-path", {}, inputPath);
|
|
process.env["PATH"] = `${inputPath}${path.delimiter}${process.env["PATH"]}`;
|
|
};
|
|
var getInput = function(name, options) {
|
|
const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
|
|
if (options && options.required && !val)
|
|
throw new Error(`Input required and not supplied: ${name}`);
|
|
if (options && options.trimWhitespace === false)
|
|
return val;
|
|
return val.trim();
|
|
};
|
|
var getMultilineInput = function(name, options) {
|
|
const inputs = getInput(name, options).split("\n").filter((x) => x !== "");
|
|
if (options && options.trimWhitespace === false)
|
|
return inputs;
|
|
return inputs.map((input) => input.trim());
|
|
};
|
|
var getBooleanInput = function(name, options) {
|
|
const trueValue = ["true", "True", "TRUE"];
|
|
const falseValue = ["false", "False", "FALSE"];
|
|
const val = getInput(name, options);
|
|
if (trueValue.includes(val))
|
|
return true;
|
|
if (falseValue.includes(val))
|
|
return false;
|
|
throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` + `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
|
|
};
|
|
var setOutput = function(name, value) {
|
|
const filePath = process.env["GITHUB_OUTPUT"] || "";
|
|
if (filePath)
|
|
return file_command_1.issueFileCommand("OUTPUT", file_command_1.prepareKeyValueMessage(name, value));
|
|
process.stdout.write(os.EOL);
|
|
command_1.issueCommand("set-output", { name }, utils_1.toCommandValue(value));
|
|
};
|
|
var setCommandEcho = function(enabled) {
|
|
command_1.issue("echo", enabled ? "on" : "off");
|
|
};
|
|
var setFailed = function(message) {
|
|
process.exitCode = ExitCode.Failure;
|
|
error(message);
|
|
};
|
|
var isDebug = function() {
|
|
return process.env["RUNNER_DEBUG"] === "1";
|
|
};
|
|
var debug = function(message) {
|
|
command_1.issueCommand("debug", {}, message);
|
|
};
|
|
var error = function(message, properties = {}) {
|
|
command_1.issueCommand("error", utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
};
|
|
var warning = function(message, properties = {}) {
|
|
command_1.issueCommand("warning", utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
};
|
|
var notice = function(message, properties = {}) {
|
|
command_1.issueCommand("notice", utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message);
|
|
};
|
|
var info = function(message) {
|
|
process.stdout.write(message + os.EOL);
|
|
};
|
|
var startGroup = function(name) {
|
|
command_1.issue("group", name);
|
|
};
|
|
var endGroup = function() {
|
|
command_1.issue("endgroup");
|
|
};
|
|
var group = function(name, fn) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
startGroup(name);
|
|
let result;
|
|
try {
|
|
result = yield fn();
|
|
} finally {
|
|
endGroup();
|
|
}
|
|
return result;
|
|
});
|
|
};
|
|
var saveState = function(name, value) {
|
|
const filePath = process.env["GITHUB_STATE"] || "";
|
|
if (filePath)
|
|
return file_command_1.issueFileCommand("STATE", file_command_1.prepareKeyValueMessage(name, value));
|
|
command_1.issueCommand("save-state", { name }, utils_1.toCommandValue(value));
|
|
};
|
|
var getState = function(name) {
|
|
return process.env[`STATE_${name}`] || "";
|
|
};
|
|
var getIDToken = function(aud) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return yield oidc_utils_1.OidcClient.getIDToken(aud);
|
|
});
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = undefined;
|
|
var command_1 = require_command();
|
|
var file_command_1 = require_file_command();
|
|
var utils_1 = require_utils();
|
|
var os = __importStar(__require("os"));
|
|
var path = __importStar(__require("path"));
|
|
var oidc_utils_1 = require_oidc_utils();
|
|
var ExitCode;
|
|
(function(ExitCode2) {
|
|
ExitCode2[ExitCode2["Success"] = 0] = "Success";
|
|
ExitCode2[ExitCode2["Failure"] = 1] = "Failure";
|
|
})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
|
|
exports.exportVariable = exportVariable;
|
|
exports.setSecret = setSecret;
|
|
exports.addPath = addPath;
|
|
exports.getInput = getInput;
|
|
exports.getMultilineInput = getMultilineInput;
|
|
exports.getBooleanInput = getBooleanInput;
|
|
exports.setOutput = setOutput;
|
|
exports.setCommandEcho = setCommandEcho;
|
|
exports.setFailed = setFailed;
|
|
exports.isDebug = isDebug;
|
|
exports.debug = debug;
|
|
exports.error = error;
|
|
exports.warning = warning;
|
|
exports.notice = notice;
|
|
exports.info = info;
|
|
exports.startGroup = startGroup;
|
|
exports.endGroup = endGroup;
|
|
exports.group = group;
|
|
exports.saveState = saveState;
|
|
exports.getState = getState;
|
|
exports.getIDToken = getIDToken;
|
|
var summary_1 = require_summary();
|
|
Object.defineProperty(exports, "summary", { enumerable: true, get: function() {
|
|
return summary_1.summary;
|
|
} });
|
|
var summary_2 = require_summary();
|
|
Object.defineProperty(exports, "markdownSummary", { enumerable: true, get: function() {
|
|
return summary_2.markdownSummary;
|
|
} });
|
|
var path_utils_1 = require_path_utils();
|
|
Object.defineProperty(exports, "toPosixPath", { enumerable: true, get: function() {
|
|
return path_utils_1.toPosixPath;
|
|
} });
|
|
Object.defineProperty(exports, "toWin32Path", { enumerable: true, get: function() {
|
|
return path_utils_1.toWin32Path;
|
|
} });
|
|
Object.defineProperty(exports, "toPlatformPath", { enumerable: true, get: function() {
|
|
return path_utils_1.toPlatformPath;
|
|
} });
|
|
});
|
|
|
|
// node_modules/@actions/io/lib/io-util.js
|
|
var require_io_util = __commonJS((exports) => {
|
|
var exists = function(fsPath) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
try {
|
|
yield exports.stat(fsPath);
|
|
} catch (err) {
|
|
if (err.code === "ENOENT")
|
|
return false;
|
|
throw err;
|
|
}
|
|
return true;
|
|
});
|
|
};
|
|
var isDirectory = function(fsPath, useStat = false) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath);
|
|
return stats.isDirectory();
|
|
});
|
|
};
|
|
var isRooted = function(p) {
|
|
p = normalizeSeparators(p);
|
|
if (!p)
|
|
throw new Error('isRooted() parameter "p" cannot be empty');
|
|
if (exports.IS_WINDOWS)
|
|
return p.startsWith("\\") || /^[A-Z]:/i.test(p);
|
|
return p.startsWith("/");
|
|
};
|
|
var tryGetExecutablePath = function(filePath, extensions) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
let stats = undefined;
|
|
try {
|
|
stats = yield exports.stat(filePath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT")
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (exports.IS_WINDOWS) {
|
|
const upperExt = path.extname(filePath).toUpperCase();
|
|
if (extensions.some((validExt) => validExt.toUpperCase() === upperExt))
|
|
return filePath;
|
|
} else if (isUnixExecutable(stats))
|
|
return filePath;
|
|
}
|
|
const originalFilePath = filePath;
|
|
for (const extension of extensions) {
|
|
filePath = originalFilePath + extension;
|
|
stats = undefined;
|
|
try {
|
|
stats = yield exports.stat(filePath);
|
|
} catch (err) {
|
|
if (err.code !== "ENOENT")
|
|
console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
|
|
}
|
|
if (stats && stats.isFile()) {
|
|
if (exports.IS_WINDOWS) {
|
|
try {
|
|
const directory = path.dirname(filePath);
|
|
const upperName = path.basename(filePath).toUpperCase();
|
|
for (const actualName of yield exports.readdir(directory))
|
|
if (upperName === actualName.toUpperCase()) {
|
|
filePath = path.join(directory, actualName);
|
|
break;
|
|
}
|
|
} catch (err) {
|
|
console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
|
|
}
|
|
return filePath;
|
|
} else if (isUnixExecutable(stats))
|
|
return filePath;
|
|
}
|
|
}
|
|
return "";
|
|
});
|
|
};
|
|
var normalizeSeparators = function(p) {
|
|
p = p || "";
|
|
if (exports.IS_WINDOWS) {
|
|
p = p.replace(/\//g, "\\");
|
|
return p.replace(/\\\\+/g, "\\");
|
|
}
|
|
return p.replace(/\/\/+/g, "/");
|
|
};
|
|
var isUnixExecutable = function(stats) {
|
|
return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid();
|
|
};
|
|
var getCmdPath = function() {
|
|
var _a2;
|
|
return (_a2 = process.env["COMSPEC"]) !== null && _a2 !== undefined ? _a2 : `cmd.exe`;
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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 _a;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getCmdPath = exports.tryGetExecutablePath = exports.isRooted = exports.isDirectory = exports.exists = exports.READONLY = exports.UV_FS_O_EXLOCK = exports.IS_WINDOWS = exports.unlink = exports.symlink = exports.stat = exports.rmdir = exports.rm = exports.rename = exports.readlink = exports.readdir = exports.open = exports.mkdir = exports.lstat = exports.copyFile = exports.chmod = undefined;
|
|
var fs = __importStar(__require("fs"));
|
|
var path = __importStar(__require("path"));
|
|
_a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.open = _a.open, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rm = _a.rm, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
|
|
exports.IS_WINDOWS = process.platform === "win32";
|
|
exports.UV_FS_O_EXLOCK = 268435456;
|
|
exports.READONLY = fs.constants.O_RDONLY;
|
|
exports.exists = exists;
|
|
exports.isDirectory = isDirectory;
|
|
exports.isRooted = isRooted;
|
|
exports.tryGetExecutablePath = tryGetExecutablePath;
|
|
exports.getCmdPath = getCmdPath;
|
|
});
|
|
|
|
// node_modules/@actions/io/lib/io.js
|
|
var require_io = __commonJS((exports) => {
|
|
var cp = function(source, dest, options = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const { force, recursive, copySourceDirectory } = readCopyOptions(options);
|
|
const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
|
|
if (destStat && destStat.isFile() && !force)
|
|
return;
|
|
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) === "")
|
|
throw new Error(`'${newDest}' and '${source}' are the same file`);
|
|
yield copyFile(source, newDest, force);
|
|
}
|
|
});
|
|
};
|
|
var mv = function(source, dest, options = {}) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (yield ioUtil.exists(dest)) {
|
|
let destExists = true;
|
|
if (yield ioUtil.isDirectory(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);
|
|
});
|
|
};
|
|
var rmRF = function(inputPath) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (ioUtil.IS_WINDOWS) {
|
|
if (/[*"<>|]/.test(inputPath))
|
|
throw new Error('File path must not contain `*`, `"`, `<`, `>` or `|` on Windows');
|
|
}
|
|
try {
|
|
yield ioUtil.rm(inputPath, {
|
|
force: true,
|
|
maxRetries: 3,
|
|
recursive: true,
|
|
retryDelay: 300
|
|
});
|
|
} catch (err) {
|
|
throw new Error(`File was unable to be removed ${err}`);
|
|
}
|
|
});
|
|
};
|
|
var mkdirP = function(fsPath) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
assert_1.ok(fsPath, "a path argument must be provided");
|
|
yield ioUtil.mkdir(fsPath, { recursive: true });
|
|
});
|
|
};
|
|
var which = function(tool, check) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!tool)
|
|
throw new Error("parameter 'tool' is required");
|
|
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 "";
|
|
});
|
|
};
|
|
var findInPath = function(tool) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!tool)
|
|
throw new Error("parameter 'tool' is required");
|
|
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 (ioUtil.isRooted(tool)) {
|
|
const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
|
|
if (filePath)
|
|
return [filePath];
|
|
return [];
|
|
}
|
|
if (tool.includes(path.sep))
|
|
return [];
|
|
const directories = [];
|
|
if (process.env.PATH) {
|
|
for (const p of process.env.PATH.split(path.delimiter))
|
|
if (p)
|
|
directories.push(p);
|
|
}
|
|
const matches = [];
|
|
for (const directory of directories) {
|
|
const filePath = yield ioUtil.tryGetExecutablePath(path.join(directory, tool), extensions);
|
|
if (filePath)
|
|
matches.push(filePath);
|
|
}
|
|
return matches;
|
|
});
|
|
};
|
|
var readCopyOptions = function(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 };
|
|
};
|
|
var cpDirRecursive = function(sourceDir, destDir, currentDepth, force) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
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())
|
|
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
|
|
else
|
|
yield copyFile(srcFile, destFile, force);
|
|
}
|
|
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
|
|
});
|
|
};
|
|
var copyFile = function(srcFile, destFile, force) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
|
|
try {
|
|
yield ioUtil.lstat(destFile);
|
|
yield ioUtil.unlink(destFile);
|
|
} catch (e) {
|
|
if (e.code === "EPERM") {
|
|
yield ioUtil.chmod(destFile, "0666");
|
|
yield ioUtil.unlink(destFile);
|
|
}
|
|
}
|
|
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);
|
|
});
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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 = undefined;
|
|
var assert_1 = __require("assert");
|
|
var path = __importStar(__require("path"));
|
|
var ioUtil = __importStar(require_io_util());
|
|
exports.cp = cp;
|
|
exports.mv = mv;
|
|
exports.rmRF = rmRF;
|
|
exports.mkdirP = mkdirP;
|
|
exports.which = which;
|
|
exports.findInPath = findInPath;
|
|
});
|
|
|
|
// node_modules/semver/semver.js
|
|
var require_semver = __commonJS((exports, module) => {
|
|
var tok = function(n) {
|
|
t[n] = R++;
|
|
};
|
|
var parse3 = function(version2, options) {
|
|
if (!options || typeof options !== "object")
|
|
options = {
|
|
loose: !!options,
|
|
includePrerelease: false
|
|
};
|
|
if (version2 instanceof SemVer)
|
|
return version2;
|
|
if (typeof version2 !== "string")
|
|
return null;
|
|
if (version2.length > MAX_LENGTH)
|
|
return null;
|
|
var r = options.loose ? re[t.LOOSE] : re[t.FULL];
|
|
if (!r.test(version2))
|
|
return null;
|
|
try {
|
|
return new SemVer(version2, options);
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
};
|
|
var valid = function(version2, options) {
|
|
var v = parse3(version2, options);
|
|
return v ? v.version : null;
|
|
};
|
|
var clean = function(version2, options) {
|
|
var s = parse3(version2.trim().replace(/^[=v]+/, ""), options);
|
|
return s ? s.version : null;
|
|
};
|
|
var SemVer = function(version2, options) {
|
|
if (!options || typeof options !== "object")
|
|
options = {
|
|
loose: !!options,
|
|
includePrerelease: false
|
|
};
|
|
if (version2 instanceof SemVer)
|
|
if (version2.loose === options.loose)
|
|
return version2;
|
|
else
|
|
version2 = version2.version;
|
|
else if (typeof version2 !== "string")
|
|
throw new TypeError("Invalid Version: " + version2);
|
|
if (version2.length > MAX_LENGTH)
|
|
throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
|
|
if (!(this instanceof SemVer))
|
|
return new SemVer(version2, options);
|
|
debug("SemVer", version2, options);
|
|
this.options = options;
|
|
this.loose = !!options.loose;
|
|
var m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
|
|
if (!m)
|
|
throw new TypeError("Invalid Version: " + version2);
|
|
this.raw = version2;
|
|
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");
|
|
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();
|
|
};
|
|
var inc = function(version2, release, loose, identifier) {
|
|
if (typeof loose === "string") {
|
|
identifier = loose;
|
|
loose = undefined;
|
|
}
|
|
try {
|
|
return new SemVer(version2, loose).inc(release, identifier).version;
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
};
|
|
var diff = function(version1, version2) {
|
|
if (eq(version1, version2))
|
|
return null;
|
|
else {
|
|
var v12 = parse3(version1);
|
|
var v2 = parse3(version2);
|
|
var prefix = "";
|
|
if (v12.prerelease.length || v2.prerelease.length) {
|
|
prefix = "pre";
|
|
var defaultResult = "prerelease";
|
|
}
|
|
for (var key in v12)
|
|
if (key === "major" || key === "minor" || key === "patch") {
|
|
if (v12[key] !== v2[key])
|
|
return prefix + key;
|
|
}
|
|
return defaultResult;
|
|
}
|
|
};
|
|
var compareIdentifiers = function(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;
|
|
};
|
|
var rcompareIdentifiers = function(a, b) {
|
|
return compareIdentifiers(b, a);
|
|
};
|
|
var major = function(a, loose) {
|
|
return new SemVer(a, loose).major;
|
|
};
|
|
var minor = function(a, loose) {
|
|
return new SemVer(a, loose).minor;
|
|
};
|
|
var patch = function(a, loose) {
|
|
return new SemVer(a, loose).patch;
|
|
};
|
|
var compare = function(a, b, loose) {
|
|
return new SemVer(a, loose).compare(new SemVer(b, loose));
|
|
};
|
|
var compareLoose = function(a, b) {
|
|
return compare(a, b, true);
|
|
};
|
|
var compareBuild = function(a, b, loose) {
|
|
var versionA = new SemVer(a, loose);
|
|
var versionB = new SemVer(b, loose);
|
|
return versionA.compare(versionB) || versionA.compareBuild(versionB);
|
|
};
|
|
var rcompare = function(a, b, loose) {
|
|
return compare(b, a, loose);
|
|
};
|
|
var sort = function(list, loose) {
|
|
return list.sort(function(a, b) {
|
|
return exports.compareBuild(a, b, loose);
|
|
});
|
|
};
|
|
var rsort = function(list, loose) {
|
|
return list.sort(function(a, b) {
|
|
return exports.compareBuild(b, a, loose);
|
|
});
|
|
};
|
|
var gt = function(a, b, loose) {
|
|
return compare(a, b, loose) > 0;
|
|
};
|
|
var lt = function(a, b, loose) {
|
|
return compare(a, b, loose) < 0;
|
|
};
|
|
var eq = function(a, b, loose) {
|
|
return compare(a, b, loose) === 0;
|
|
};
|
|
var neq = function(a, b, loose) {
|
|
return compare(a, b, loose) !== 0;
|
|
};
|
|
var gte = function(a, b, loose) {
|
|
return compare(a, b, loose) >= 0;
|
|
};
|
|
var lte = function(a, b, loose) {
|
|
return compare(a, b, loose) <= 0;
|
|
};
|
|
var cmp = function(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);
|
|
}
|
|
};
|
|
var Comparator = function(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 Range = function(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;
|
|
this.raw = range;
|
|
this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
|
|
return this.parseRange(range2.trim());
|
|
}, this).filter(function(c) {
|
|
return c.length;
|
|
});
|
|
if (!this.set.length)
|
|
throw new TypeError("Invalid SemVer Range: " + range);
|
|
this.format();
|
|
};
|
|
var isSatisfiable = function(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;
|
|
};
|
|
var toComparators = function(range, options) {
|
|
return new Range(range, options).set.map(function(comp) {
|
|
return comp.map(function(c) {
|
|
return c.value;
|
|
}).join(" ").trim().split(" ");
|
|
});
|
|
};
|
|
var parseComparator = function(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;
|
|
};
|
|
var isX = function(id) {
|
|
return !id || id.toLowerCase() === "x" || id === "*";
|
|
};
|
|
var replaceTildes = function(comp, options) {
|
|
return comp.trim().split(/\s+/).map(function(comp2) {
|
|
return replaceTilde(comp2, options);
|
|
}).join(" ");
|
|
};
|
|
var replaceTilde = function(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))
|
|
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
|
|
ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
|
|
debug("tilde return", ret);
|
|
return ret;
|
|
});
|
|
};
|
|
var replaceCarets = function(comp, options) {
|
|
return comp.trim().split(/\s+/).map(function(comp2) {
|
|
return replaceCaret(comp2, options);
|
|
}).join(" ");
|
|
};
|
|
var replaceCaret = function(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;
|
|
});
|
|
};
|
|
var replaceXRanges = function(comp, options) {
|
|
debug("replaceXRanges", comp, options);
|
|
return comp.split(/\s+/).map(function(comp2) {
|
|
return replaceXRange(comp2, options);
|
|
}).join(" ");
|
|
};
|
|
var replaceXRange = function(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 = "";
|
|
pr = options.includePrerelease ? "-0" : "";
|
|
if (xM)
|
|
if (gtlt === ">" || gtlt === "<")
|
|
ret = "<0.0.0-0";
|
|
else
|
|
ret = "*";
|
|
else if (gtlt && anyX) {
|
|
if (xm)
|
|
m = 0;
|
|
p = 0;
|
|
if (gtlt === ">") {
|
|
gtlt = ">=";
|
|
if (xm) {
|
|
M = +M + 1;
|
|
m = 0;
|
|
p = 0;
|
|
} else {
|
|
m = +m + 1;
|
|
p = 0;
|
|
}
|
|
} else if (gtlt === "<=") {
|
|
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;
|
|
});
|
|
};
|
|
var replaceStars = function(comp, options) {
|
|
debug("replaceStars", comp, options);
|
|
return comp.trim().replace(re[t.STAR], "");
|
|
};
|
|
var hyphenReplace = function($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();
|
|
};
|
|
var testSet = function(set, version2, options) {
|
|
for (var i2 = 0;i2 < set.length; i2++)
|
|
if (!set[i2].test(version2))
|
|
return false;
|
|
if (version2.prerelease.length && !options.includePrerelease) {
|
|
for (i2 = 0;i2 < set.length; i2++) {
|
|
debug(set[i2].semver);
|
|
if (set[i2].semver === ANY)
|
|
continue;
|
|
if (set[i2].semver.prerelease.length > 0) {
|
|
var allowed = set[i2].semver;
|
|
if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
var satisfies = function(version2, range, options) {
|
|
try {
|
|
range = new Range(range, options);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
return range.test(version2);
|
|
};
|
|
var maxSatisfying = function(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)) {
|
|
if (!max || maxSV.compare(v) === -1) {
|
|
max = v;
|
|
maxSV = new SemVer(max, options);
|
|
}
|
|
}
|
|
});
|
|
return max;
|
|
};
|
|
var minSatisfying = function(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)) {
|
|
if (!min || minSV.compare(v) === 1) {
|
|
min = v;
|
|
minSV = new SemVer(min, options);
|
|
}
|
|
}
|
|
});
|
|
return min;
|
|
};
|
|
var minVersion = function(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 i2 = 0;i2 < range.set.length; ++i2) {
|
|
var comparators = range.set[i2];
|
|
comparators.forEach(function(comparator) {
|
|
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();
|
|
case "":
|
|
case ">=":
|
|
if (!minver || gt(minver, compver))
|
|
minver = compver;
|
|
break;
|
|
case "<":
|
|
case "<=":
|
|
break;
|
|
default:
|
|
throw new Error("Unexpected operation: " + comparator.operator);
|
|
}
|
|
});
|
|
}
|
|
if (minver && range.test(minver))
|
|
return minver;
|
|
return null;
|
|
};
|
|
var validRange = function(range, options) {
|
|
try {
|
|
return new Range(range, options).range || "*";
|
|
} catch (er) {
|
|
return null;
|
|
}
|
|
};
|
|
var ltr = function(version2, range, options) {
|
|
return outside(version2, range, "<", options);
|
|
};
|
|
var gtr = function(version2, range, options) {
|
|
return outside(version2, range, ">", options);
|
|
};
|
|
var outside = function(version2, range, hilo, options) {
|
|
version2 = new SemVer(version2, 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 (satisfies(version2, range, options))
|
|
return false;
|
|
for (var i2 = 0;i2 < range.set.length; ++i2) {
|
|
var comparators = range.set[i2];
|
|
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 (high.operator === comp || high.operator === ecomp)
|
|
return false;
|
|
if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver))
|
|
return false;
|
|
else if (low.operator === ecomp && ltfn(version2, low.semver))
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
var prerelease = function(version2, options) {
|
|
var parsed = parse3(version2, options);
|
|
return parsed && parsed.prerelease.length ? parsed.prerelease : null;
|
|
};
|
|
var intersects = function(r1, r2, options) {
|
|
r1 = new Range(r1, options);
|
|
r2 = new Range(r2, options);
|
|
return r1.intersects(r2);
|
|
};
|
|
var coerce = function(version2, options) {
|
|
if (version2 instanceof SemVer)
|
|
return version2;
|
|
if (typeof version2 === "number")
|
|
version2 = String(version2);
|
|
if (typeof version2 !== "string")
|
|
return null;
|
|
options = options || {};
|
|
var match = null;
|
|
if (!options.rtl)
|
|
match = version2.match(re[t.COERCE]);
|
|
else {
|
|
var next;
|
|
while ((next = re[t.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.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;
|
|
}
|
|
re[t.COERCERTL].lastIndex = -1;
|
|
}
|
|
if (match === null)
|
|
return null;
|
|
return parse3(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
|
|
};
|
|
exports = module.exports = SemVer;
|
|
var debug;
|
|
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() {
|
|
};
|
|
exports.SEMVER_SPEC_VERSION = "2.0.0";
|
|
var MAX_LENGTH = 256;
|
|
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
|
|
var MAX_SAFE_COMPONENT_LENGTH = 16;
|
|
var re = exports.re = [];
|
|
var src = exports.src = [];
|
|
var t = exports.tokens = {};
|
|
var R = 0;
|
|
tok("NUMERICIDENTIFIER");
|
|
src[t.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
|
|
tok("NUMERICIDENTIFIERLOOSE");
|
|
src[t.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
|
|
tok("NONNUMERICIDENTIFIER");
|
|
src[t.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
|
|
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] + ")";
|
|
tok("PRERELEASEIDENTIFIER");
|
|
src[t.PRERELEASEIDENTIFIER] = "(?:" + src[t.NUMERICIDENTIFIER] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
|
|
tok("PRERELEASEIDENTIFIERLOOSE");
|
|
src[t.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t.NUMERICIDENTIFIERLOOSE] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
|
|
tok("PRERELEASE");
|
|
src[t.PRERELEASE] = "(?:-(" + src[t.PRERELEASEIDENTIFIER] + "(?:\\." + src[t.PRERELEASEIDENTIFIER] + ")*))";
|
|
tok("PRERELEASELOOSE");
|
|
src[t.PRERELEASELOOSE] = "(?:-?(" + src[t.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t.PRERELEASEIDENTIFIERLOOSE] + ")*))";
|
|
tok("BUILDIDENTIFIER");
|
|
src[t.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
|
|
tok("BUILD");
|
|
src[t.BUILD] = "(?:\\+(" + src[t.BUILDIDENTIFIER] + "(?:\\." + src[t.BUILDIDENTIFIER] + ")*))";
|
|
tok("FULL");
|
|
tok("FULLPLAIN");
|
|
src[t.FULLPLAIN] = "v?" + src[t.MAINVERSION] + src[t.PRERELEASE] + "?" + src[t.BUILD] + "?";
|
|
src[t.FULL] = "^" + src[t.FULLPLAIN] + "$";
|
|
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] = "((?:<|>)?=?)";
|
|
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] + "$";
|
|
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");
|
|
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] + "$";
|
|
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] + "$";
|
|
tok("COMPARATORLOOSE");
|
|
src[t.COMPARATORLOOSE] = "^" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + ")$|^$";
|
|
tok("COMPARATOR");
|
|
src[t.COMPARATOR] = "^" + src[t.GTLT] + "\\s*(" + src[t.FULLPLAIN] + ")$|^$";
|
|
tok("COMPARATORTRIM");
|
|
src[t.COMPARATORTRIM] = "(\\s*)" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + "|" + src[t.XRANGEPLAIN] + ")";
|
|
re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], "g");
|
|
var comparatorTrimReplace = "$1$2$3";
|
|
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*$";
|
|
tok("STAR");
|
|
src[t.STAR] = "(<|>)?=?\\s*\\*";
|
|
for (i = 0;i < R; i++) {
|
|
debug(i, src[i]);
|
|
if (!re[i])
|
|
re[i] = new RegExp(src[i]);
|
|
}
|
|
var i;
|
|
exports.parse = parse3;
|
|
exports.valid = valid;
|
|
exports.clean = clean;
|
|
exports.SemVer = SemVer;
|
|
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);
|
|
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 i2 = 0;
|
|
do {
|
|
var a = this.prerelease[i2];
|
|
var b = other.prerelease[i2];
|
|
debug("prerelease compare", i2, 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 (++i2);
|
|
};
|
|
SemVer.prototype.compareBuild = function(other) {
|
|
if (!(other instanceof SemVer))
|
|
other = new SemVer(other, this.options);
|
|
var i2 = 0;
|
|
do {
|
|
var a = this.build[i2];
|
|
var b = other.build[i2];
|
|
debug("prerelease compare", i2, 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 (++i2);
|
|
};
|
|
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":
|
|
this.prerelease.length = 0;
|
|
this.inc("patch", identifier);
|
|
this.inc("pre", identifier);
|
|
break;
|
|
case "prerelease":
|
|
if (this.prerelease.length === 0)
|
|
this.inc("patch", identifier);
|
|
this.inc("pre", identifier);
|
|
break;
|
|
case "major":
|
|
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.patch !== 0 || this.prerelease.length === 0)
|
|
this.minor++;
|
|
this.patch = 0;
|
|
this.prerelease = [];
|
|
break;
|
|
case "patch":
|
|
if (this.prerelease.length === 0)
|
|
this.patch++;
|
|
this.prerelease = [];
|
|
break;
|
|
case "pre":
|
|
if (this.prerelease.length === 0)
|
|
this.prerelease = [0];
|
|
else {
|
|
var i2 = this.prerelease.length;
|
|
while (--i2 >= 0)
|
|
if (typeof this.prerelease[i2] === "number") {
|
|
this.prerelease[i2]++;
|
|
i2 = -2;
|
|
}
|
|
if (i2 === -1)
|
|
this.prerelease.push(0);
|
|
}
|
|
if (identifier)
|
|
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;
|
|
exports.diff = diff;
|
|
exports.compareIdentifiers = compareIdentifiers;
|
|
var numeric = /^[0-9]+$/;
|
|
exports.rcompareIdentifiers = rcompareIdentifiers;
|
|
exports.major = major;
|
|
exports.minor = minor;
|
|
exports.patch = patch;
|
|
exports.compare = compare;
|
|
exports.compareLoose = compareLoose;
|
|
exports.compareBuild = compareBuild;
|
|
exports.rcompare = rcompare;
|
|
exports.sort = sort;
|
|
exports.rsort = rsort;
|
|
exports.gt = gt;
|
|
exports.lt = lt;
|
|
exports.eq = eq;
|
|
exports.neq = neq;
|
|
exports.gte = gte;
|
|
exports.lte = lte;
|
|
exports.cmp = cmp;
|
|
exports.Comparator = Comparator;
|
|
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 (!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(version2) {
|
|
debug("Comparator.test", version2, this.options.loose);
|
|
if (this.semver === ANY || version2 === ANY)
|
|
return true;
|
|
if (typeof version2 === "string")
|
|
try {
|
|
version2 = new SemVer(version2, this.options);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
return cmp(version2, 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;
|
|
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();
|
|
var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
|
|
range = range.replace(hr, hyphenReplace);
|
|
debug("hyphen replace", range);
|
|
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
|
|
debug("comparator trim", range, re[t.COMPARATORTRIM]);
|
|
range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
|
|
range = range.replace(re[t.CARETTRIM], caretTrimReplace);
|
|
range = range.split(/\s+/).join(" ");
|
|
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)
|
|
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);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
exports.toComparators = toComparators;
|
|
Range.prototype.test = function(version2) {
|
|
if (!version2)
|
|
return false;
|
|
if (typeof version2 === "string")
|
|
try {
|
|
version2 = new SemVer(version2, this.options);
|
|
} catch (er) {
|
|
return false;
|
|
}
|
|
for (var i2 = 0;i2 < this.set.length; i2++)
|
|
if (testSet(this.set[i2], version2, this.options))
|
|
return true;
|
|
return false;
|
|
};
|
|
exports.satisfies = satisfies;
|
|
exports.maxSatisfying = maxSatisfying;
|
|
exports.minSatisfying = minSatisfying;
|
|
exports.minVersion = minVersion;
|
|
exports.validRange = validRange;
|
|
exports.ltr = ltr;
|
|
exports.gtr = gtr;
|
|
exports.outside = outside;
|
|
exports.prerelease = prerelease;
|
|
exports.intersects = intersects;
|
|
exports.coerce = coerce;
|
|
});
|
|
|
|
// node_modules/@actions/tool-cache/lib/manifest.js
|
|
var require_manifest = __commonJS((exports, module) => {
|
|
var _findMatch = function(versionSpec, stable, candidates, archFilter) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const platFilter = os.platform();
|
|
let result;
|
|
let match;
|
|
let file;
|
|
for (const candidate of candidates) {
|
|
const version2 = candidate.version;
|
|
core_1.debug(`check ${version2} satisfies ${versionSpec}`);
|
|
if (semver.satisfies(version2, versionSpec) && (!stable || candidate.stable === stable)) {
|
|
file = candidate.files.find((item) => {
|
|
core_1.debug(`${item.arch}===${archFilter} && ${item.platform}===${platFilter}`);
|
|
let chk = item.arch === archFilter && item.platform === platFilter;
|
|
if (chk && item.platform_version) {
|
|
const osVersion = module.exports._getOsVersion();
|
|
if (osVersion === item.platform_version)
|
|
chk = true;
|
|
else
|
|
chk = semver.satisfies(osVersion, item.platform_version);
|
|
}
|
|
return chk;
|
|
});
|
|
if (file) {
|
|
core_1.debug(`matched ${candidate.version}`);
|
|
match = candidate;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (match && file) {
|
|
result = Object.assign({}, match);
|
|
result.files = [file];
|
|
}
|
|
return result;
|
|
});
|
|
};
|
|
var _getOsVersion = function() {
|
|
const plat = os.platform();
|
|
let version2 = "";
|
|
if (plat === "darwin")
|
|
version2 = cp.execSync("sw_vers -productVersion").toString();
|
|
else if (plat === "linux") {
|
|
const lsbContents = module.exports._readLinuxVersionFile();
|
|
if (lsbContents) {
|
|
const lines = lsbContents.split("\n");
|
|
for (const line of lines) {
|
|
const parts = line.split("=");
|
|
if (parts.length === 2 && (parts[0].trim() === "VERSION_ID" || parts[0].trim() === "DISTRIB_RELEASE")) {
|
|
version2 = parts[1].trim().replace(/^"/, "").replace(/"$/, "");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return version2;
|
|
};
|
|
var _readLinuxVersionFile = function() {
|
|
const lsbReleaseFile = "/etc/lsb-release";
|
|
const osReleaseFile = "/etc/os-release";
|
|
let contents = "";
|
|
if (fs.existsSync(lsbReleaseFile))
|
|
contents = fs.readFileSync(lsbReleaseFile).toString();
|
|
else if (fs.existsSync(osReleaseFile))
|
|
contents = fs.readFileSync(osReleaseFile).toString();
|
|
return contents;
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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._readLinuxVersionFile = exports._getOsVersion = exports._findMatch = undefined;
|
|
var semver = __importStar(require_semver());
|
|
var core_1 = require_core();
|
|
var os = __require("os");
|
|
var cp = __require("child_process");
|
|
var fs = __require("fs");
|
|
exports._findMatch = _findMatch;
|
|
exports._getOsVersion = _getOsVersion;
|
|
exports._readLinuxVersionFile = _readLinuxVersionFile;
|
|
});
|
|
|
|
// node_modules/uuid/lib/rng.js
|
|
var require_rng = __commonJS((exports, module) => {
|
|
var crypto4 = __require("crypto");
|
|
module.exports = function nodeRNG() {
|
|
return crypto4.randomBytes(16);
|
|
};
|
|
});
|
|
|
|
// node_modules/uuid/lib/bytesToUuid.js
|
|
var require_bytesToUuid = __commonJS((exports, module) => {
|
|
var bytesToUuid = function(buf, offset) {
|
|
var i2 = offset || 0;
|
|
var bth = byteToHex2;
|
|
return [
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
"-",
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
"-",
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
"-",
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
"-",
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]],
|
|
bth[buf[i2++]]
|
|
].join("");
|
|
};
|
|
var byteToHex2 = [];
|
|
for (i = 0;i < 256; ++i)
|
|
byteToHex2[i] = (i + 256).toString(16).substr(1);
|
|
var i;
|
|
module.exports = bytesToUuid;
|
|
});
|
|
|
|
// node_modules/uuid/v4.js
|
|
var require_v4 = __commonJS((exports, module) => {
|
|
var v42 = function(options, buf, offset) {
|
|
var i = buf && offset || 0;
|
|
if (typeof options == "string") {
|
|
buf = options === "binary" ? new Array(16) : null;
|
|
options = null;
|
|
}
|
|
options = options || {};
|
|
var rnds = options.random || (options.rng || rng4)();
|
|
rnds[6] = rnds[6] & 15 | 64;
|
|
rnds[8] = rnds[8] & 63 | 128;
|
|
if (buf)
|
|
for (var ii = 0;ii < 16; ++ii)
|
|
buf[i + ii] = rnds[ii];
|
|
return buf || bytesToUuid(rnds);
|
|
};
|
|
var rng4 = require_rng();
|
|
var bytesToUuid = require_bytesToUuid();
|
|
module.exports = v42;
|
|
});
|
|
|
|
// node_modules/@actions/exec/lib/toolrunner.js
|
|
var require_toolrunner = __commonJS((exports) => {
|
|
var argStringToArray = function(argString) {
|
|
const args = [];
|
|
let inQuotes = false;
|
|
let escaped = false;
|
|
let arg = "";
|
|
function append(c) {
|
|
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;
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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 = undefined;
|
|
var os = __importStar(__require("os"));
|
|
var events = __importStar(__require("events"));
|
|
var child = __importStar(__require("child_process"));
|
|
var path = __importStar(__require("path"));
|
|
var io = __importStar(require_io());
|
|
var ioUtil = __importStar(require_io_util());
|
|
var timers_1 = __require("timers");
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
|
|
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]";
|
|
if (IS_WINDOWS)
|
|
if (this._isCmdFile()) {
|
|
cmd += toolPath;
|
|
for (const a of args)
|
|
cmd += ` ${a}`;
|
|
} else if (options.windowsVerbatimArguments) {
|
|
cmd += `"${toolPath}"`;
|
|
for (const a of args)
|
|
cmd += ` ${a}`;
|
|
} else {
|
|
cmd += this._windowsQuoteCmdArg(toolPath);
|
|
for (const a of args)
|
|
cmd += ` ${this._windowsQuoteCmdArg(a)}`;
|
|
}
|
|
else {
|
|
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);
|
|
s = s.substring(n + os.EOL.length);
|
|
n = s.indexOf(os.EOL);
|
|
}
|
|
return s;
|
|
} catch (err) {
|
|
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) {
|
|
if (!this._isCmdFile())
|
|
return this._uvQuoteCmdArg(arg);
|
|
if (!arg)
|
|
return '""';
|
|
const cmdSpecialChars = [
|
|
" ",
|
|
"\t",
|
|
"&",
|
|
"(",
|
|
")",
|
|
"[",
|
|
"]",
|
|
"{",
|
|
"}",
|
|
"^",
|
|
"=",
|
|
";",
|
|
"!",
|
|
"'",
|
|
"+",
|
|
",",
|
|
"`",
|
|
"~",
|
|
"|",
|
|
"<",
|
|
">",
|
|
'"'
|
|
];
|
|
let needsQuotes = false;
|
|
for (const char of arg)
|
|
if (cmdSpecialChars.some((x) => x === char)) {
|
|
needsQuotes = true;
|
|
break;
|
|
}
|
|
if (!needsQuotes)
|
|
return arg;
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i = arg.length;i > 0; i--) {
|
|
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("");
|
|
}
|
|
_uvQuoteCmdArg(arg) {
|
|
if (!arg)
|
|
return '""';
|
|
if (!arg.includes(" ") && !arg.includes("\t") && !arg.includes('"'))
|
|
return arg;
|
|
if (!arg.includes('"') && !arg.includes("\\"))
|
|
return `"${arg}"`;
|
|
let reverse = '"';
|
|
let quoteHit = true;
|
|
for (let i = arg.length;i > 0; i--) {
|
|
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 || 1e4
|
|
};
|
|
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() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\")))
|
|
this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
|
|
this.toolPath = yield io.which(this.toolPath, true);
|
|
return new Promise((resolve, reject) => __awaiter(this, undefined, undefined, 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;
|
|
exports.argStringToArray = argStringToArray;
|
|
|
|
class ExecState extends events.EventEmitter {
|
|
constructor(options, toolPath) {
|
|
super();
|
|
this.processClosed = false;
|
|
this.processError = "";
|
|
this.processExitCode = 0;
|
|
this.processExited = false;
|
|
this.processStderr = false;
|
|
this.delay = 1e4;
|
|
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() {
|
|
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`);
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@actions/exec/lib/exec.js
|
|
var require_exec = __commonJS((exports) => {
|
|
var exec = function(commandLine, args, options) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const commandArgs = tr.argStringToArray(commandLine);
|
|
if (commandArgs.length === 0)
|
|
throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
|
|
const toolPath = commandArgs[0];
|
|
args = commandArgs.slice(1).concat(args || []);
|
|
const runner = new tr.ToolRunner(toolPath, args, options);
|
|
return runner.exec();
|
|
});
|
|
};
|
|
var getExecOutput = function(commandLine, args, options) {
|
|
var _a, _b;
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
let stdout = "";
|
|
let stderr = "";
|
|
const stdoutDecoder = new string_decoder_1.StringDecoder("utf8");
|
|
const stderrDecoder = new string_decoder_1.StringDecoder("utf8");
|
|
const originalStdoutListener = (_a = options === null || options === undefined ? undefined : options.listeners) === null || _a === undefined ? undefined : _a.stdout;
|
|
const originalStdErrListener = (_b = options === null || options === undefined ? undefined : options.listeners) === null || _b === undefined ? undefined : _b.stderr;
|
|
const stdErrListener = (data) => {
|
|
stderr += stderrDecoder.write(data);
|
|
if (originalStdErrListener)
|
|
originalStdErrListener(data);
|
|
};
|
|
const stdOutListener = (data) => {
|
|
stdout += stdoutDecoder.write(data);
|
|
if (originalStdoutListener)
|
|
originalStdoutListener(data);
|
|
};
|
|
const listeners = Object.assign(Object.assign({}, options === null || options === undefined ? undefined : options.listeners), { stdout: stdOutListener, stderr: stdErrListener });
|
|
const exitCode = yield exec(commandLine, args, Object.assign(Object.assign({}, options), { listeners }));
|
|
stdout += stdoutDecoder.end();
|
|
stderr += stderrDecoder.end();
|
|
return {
|
|
exitCode,
|
|
stdout,
|
|
stderr
|
|
};
|
|
});
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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.getExecOutput = exports.exec = undefined;
|
|
var string_decoder_1 = __require("string_decoder");
|
|
var tr = __importStar(require_toolrunner());
|
|
exports.exec = exec;
|
|
exports.getExecOutput = getExecOutput;
|
|
});
|
|
|
|
// node_modules/@actions/tool-cache/lib/retry-helper.js
|
|
var require_retry_helper = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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.RetryHelper = undefined;
|
|
var core = __importStar(require_core());
|
|
|
|
class RetryHelper {
|
|
constructor(maxAttempts, minSeconds, maxSeconds) {
|
|
if (maxAttempts < 1)
|
|
throw new Error("max attempts should be greater than or equal to 1");
|
|
this.maxAttempts = maxAttempts;
|
|
this.minSeconds = Math.floor(minSeconds);
|
|
this.maxSeconds = Math.floor(maxSeconds);
|
|
if (this.minSeconds > this.maxSeconds)
|
|
throw new Error("min seconds should be less than or equal to max seconds");
|
|
}
|
|
execute(action, isRetryable) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
let attempt = 1;
|
|
while (attempt < this.maxAttempts) {
|
|
try {
|
|
return yield action();
|
|
} catch (err) {
|
|
if (isRetryable && !isRetryable(err))
|
|
throw err;
|
|
core.info(err.message);
|
|
}
|
|
const seconds = this.getSleepAmount();
|
|
core.info(`Waiting ${seconds} seconds before trying again`);
|
|
yield this.sleep(seconds);
|
|
attempt++;
|
|
}
|
|
return yield action();
|
|
});
|
|
}
|
|
getSleepAmount() {
|
|
return Math.floor(Math.random() * (this.maxSeconds - this.minSeconds + 1)) + this.minSeconds;
|
|
}
|
|
sleep(seconds) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
|
|
});
|
|
}
|
|
}
|
|
exports.RetryHelper = RetryHelper;
|
|
});
|
|
|
|
// node_modules/@actions/tool-cache/lib/tool-cache.js
|
|
var require_tool_cache = __commonJS((exports) => {
|
|
var downloadTool = function(url, dest, auth, headers) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
dest = dest || path.join(_getTempDirectory(), v4_1.default());
|
|
yield io.mkdirP(path.dirname(dest));
|
|
core.debug(`Downloading ${url}`);
|
|
core.debug(`Destination ${dest}`);
|
|
const maxAttempts = 3;
|
|
const minSeconds = _getGlobal("TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS", 10);
|
|
const maxSeconds = _getGlobal("TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS", 20);
|
|
const retryHelper = new retry_helper_1.RetryHelper(maxAttempts, minSeconds, maxSeconds);
|
|
return yield retryHelper.execute(() => __awaiter(this, undefined, undefined, function* () {
|
|
return yield downloadToolAttempt(url, dest || "", auth, headers);
|
|
}), (err) => {
|
|
if (err instanceof HTTPError && err.httpStatusCode) {
|
|
if (err.httpStatusCode < 500 && err.httpStatusCode !== 408 && err.httpStatusCode !== 429)
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
});
|
|
};
|
|
var downloadToolAttempt = function(url, dest, auth, headers) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (fs.existsSync(dest))
|
|
throw new Error(`Destination file path ${dest} already exists`);
|
|
const http = new httpm.HttpClient(userAgent, [], {
|
|
allowRetries: false
|
|
});
|
|
if (auth) {
|
|
core.debug("set auth");
|
|
if (headers === undefined)
|
|
headers = {};
|
|
headers.authorization = auth;
|
|
}
|
|
const response = yield http.get(url, headers);
|
|
if (response.message.statusCode !== 200) {
|
|
const err = new HTTPError(response.message.statusCode);
|
|
core.debug(`Failed to download from "${url}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
|
|
throw err;
|
|
}
|
|
const pipeline = util.promisify(stream.pipeline);
|
|
const responseMessageFactory = _getGlobal("TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY", () => response.message);
|
|
const readStream = responseMessageFactory();
|
|
let succeeded = false;
|
|
try {
|
|
yield pipeline(readStream, fs.createWriteStream(dest));
|
|
core.debug("download complete");
|
|
succeeded = true;
|
|
return dest;
|
|
} finally {
|
|
if (!succeeded) {
|
|
core.debug("download failed");
|
|
try {
|
|
yield io.rmRF(dest);
|
|
} catch (err) {
|
|
core.debug(`Failed to delete '${dest}'. ${err.message}`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var extract7z = function(file, dest, _7zPath) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
assert_1.ok(IS_WINDOWS, "extract7z() not supported on current OS");
|
|
assert_1.ok(file, 'parameter "file" is required');
|
|
dest = yield _createExtractFolder(dest);
|
|
const originalCwd = process.cwd();
|
|
process.chdir(dest);
|
|
if (_7zPath)
|
|
try {
|
|
const logLevel = core.isDebug() ? "-bb1" : "-bb0";
|
|
const args = [
|
|
"x",
|
|
logLevel,
|
|
"-bd",
|
|
"-sccUTF-8",
|
|
file
|
|
];
|
|
const options = {
|
|
silent: true
|
|
};
|
|
yield exec_1.exec(`"${_7zPath}"`, args, options);
|
|
} finally {
|
|
process.chdir(originalCwd);
|
|
}
|
|
else {
|
|
const escapedScript = path.join(__dirname, "..", "scripts", "Invoke-7zdec.ps1").replace(/'/g, "''").replace(/"|\n|\r/g, "");
|
|
const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, "");
|
|
const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, "");
|
|
const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`;
|
|
const args = [
|
|
"-NoLogo",
|
|
"-Sta",
|
|
"-NoProfile",
|
|
"-NonInteractive",
|
|
"-ExecutionPolicy",
|
|
"Unrestricted",
|
|
"-Command",
|
|
command
|
|
];
|
|
const options = {
|
|
silent: true
|
|
};
|
|
try {
|
|
const powershellPath = yield io.which("powershell", true);
|
|
yield exec_1.exec(`"${powershellPath}"`, args, options);
|
|
} finally {
|
|
process.chdir(originalCwd);
|
|
}
|
|
}
|
|
return dest;
|
|
});
|
|
};
|
|
var extractTar = function(file, dest, flags = "xz") {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!file)
|
|
throw new Error("parameter 'file' is required");
|
|
dest = yield _createExtractFolder(dest);
|
|
core.debug("Checking tar --version");
|
|
let versionOutput = "";
|
|
yield exec_1.exec("tar --version", [], {
|
|
ignoreReturnCode: true,
|
|
silent: true,
|
|
listeners: {
|
|
stdout: (data) => versionOutput += data.toString(),
|
|
stderr: (data) => versionOutput += data.toString()
|
|
}
|
|
});
|
|
core.debug(versionOutput.trim());
|
|
const isGnuTar = versionOutput.toUpperCase().includes("GNU TAR");
|
|
let args;
|
|
if (flags instanceof Array)
|
|
args = flags;
|
|
else
|
|
args = [flags];
|
|
if (core.isDebug() && !flags.includes("v"))
|
|
args.push("-v");
|
|
let destArg = dest;
|
|
let fileArg = file;
|
|
if (IS_WINDOWS && isGnuTar) {
|
|
args.push("--force-local");
|
|
destArg = dest.replace(/\\/g, "/");
|
|
fileArg = file.replace(/\\/g, "/");
|
|
}
|
|
if (isGnuTar) {
|
|
args.push("--warning=no-unknown-keyword");
|
|
args.push("--overwrite");
|
|
}
|
|
args.push("-C", destArg, "-f", fileArg);
|
|
yield exec_1.exec(`tar`, args);
|
|
return dest;
|
|
});
|
|
};
|
|
var extractXar = function(file, dest, flags = []) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
assert_1.ok(IS_MAC, "extractXar() not supported on current OS");
|
|
assert_1.ok(file, 'parameter "file" is required');
|
|
dest = yield _createExtractFolder(dest);
|
|
let args;
|
|
if (flags instanceof Array)
|
|
args = flags;
|
|
else
|
|
args = [flags];
|
|
args.push("-x", "-C", dest, "-f", file);
|
|
if (core.isDebug())
|
|
args.push("-v");
|
|
const xarPath = yield io.which("xar", true);
|
|
yield exec_1.exec(`"${xarPath}"`, _unique(args));
|
|
return dest;
|
|
});
|
|
};
|
|
var extractZip = function(file, dest) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!file)
|
|
throw new Error("parameter 'file' is required");
|
|
dest = yield _createExtractFolder(dest);
|
|
if (IS_WINDOWS)
|
|
yield extractZipWin(file, dest);
|
|
else
|
|
yield extractZipNix(file, dest);
|
|
return dest;
|
|
});
|
|
};
|
|
var extractZipWin = function(file, dest) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, "");
|
|
const escapedDest = dest.replace(/'/g, "''").replace(/"|\n|\r/g, "");
|
|
const pwshPath = yield io.which("pwsh", false);
|
|
if (pwshPath) {
|
|
const pwshCommand = [
|
|
`\$ErrorActionPreference = 'Stop' ;`,
|
|
`try { Add-Type -AssemblyName System.IO.Compression.ZipFile } catch { } ;`,
|
|
`try { [System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', \$true) }`,
|
|
`catch { if ((\$_.Exception.GetType().FullName -eq 'System.Management.Automation.MethodException') -or (\$_.Exception.GetType().FullName -eq 'System.Management.Automation.RuntimeException') ){ Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force } else { throw \$_ } } ;`
|
|
].join(" ");
|
|
const args = [
|
|
"-NoLogo",
|
|
"-NoProfile",
|
|
"-NonInteractive",
|
|
"-ExecutionPolicy",
|
|
"Unrestricted",
|
|
"-Command",
|
|
pwshCommand
|
|
];
|
|
core.debug(`Using pwsh at path: ${pwshPath}`);
|
|
yield exec_1.exec(`"${pwshPath}"`, args);
|
|
} else {
|
|
const powershellCommand = [
|
|
`\$ErrorActionPreference = 'Stop' ;`,
|
|
`try { Add-Type -AssemblyName System.IO.Compression.FileSystem } catch { } ;`,
|
|
`if ((Get-Command -Name Expand-Archive -Module Microsoft.PowerShell.Archive -ErrorAction Ignore)) { Expand-Archive -LiteralPath '${escapedFile}' -DestinationPath '${escapedDest}' -Force }`,
|
|
`else {[System.IO.Compression.ZipFile]::ExtractToDirectory('${escapedFile}', '${escapedDest}', \$true) }`
|
|
].join(" ");
|
|
const args = [
|
|
"-NoLogo",
|
|
"-Sta",
|
|
"-NoProfile",
|
|
"-NonInteractive",
|
|
"-ExecutionPolicy",
|
|
"Unrestricted",
|
|
"-Command",
|
|
powershellCommand
|
|
];
|
|
const powershellPath = yield io.which("powershell", true);
|
|
core.debug(`Using powershell at path: ${powershellPath}`);
|
|
yield exec_1.exec(`"${powershellPath}"`, args);
|
|
}
|
|
});
|
|
};
|
|
var extractZipNix = function(file, dest) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const unzipPath = yield io.which("unzip", true);
|
|
const args = [file];
|
|
if (!core.isDebug())
|
|
args.unshift("-q");
|
|
args.unshift("-o");
|
|
yield exec_1.exec(`"${unzipPath}"`, args, { cwd: dest });
|
|
});
|
|
};
|
|
var cacheDir = function(sourceDir, tool, version2, arch) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
version2 = semver.clean(version2) || version2;
|
|
arch = arch || os.arch();
|
|
core.debug(`Caching tool ${tool} ${version2} ${arch}`);
|
|
core.debug(`source dir: ${sourceDir}`);
|
|
if (!fs.statSync(sourceDir).isDirectory())
|
|
throw new Error("sourceDir is not a directory");
|
|
const destPath = yield _createToolPath(tool, version2, arch);
|
|
for (const itemName of fs.readdirSync(sourceDir)) {
|
|
const s = path.join(sourceDir, itemName);
|
|
yield io.cp(s, destPath, { recursive: true });
|
|
}
|
|
_completeToolPath(tool, version2, arch);
|
|
return destPath;
|
|
});
|
|
};
|
|
var cacheFile = function(sourceFile, targetFile, tool, version2, arch) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
version2 = semver.clean(version2) || version2;
|
|
arch = arch || os.arch();
|
|
core.debug(`Caching tool ${tool} ${version2} ${arch}`);
|
|
core.debug(`source file: ${sourceFile}`);
|
|
if (!fs.statSync(sourceFile).isFile())
|
|
throw new Error("sourceFile is not a file");
|
|
const destFolder = yield _createToolPath(tool, version2, arch);
|
|
const destPath = path.join(destFolder, targetFile);
|
|
core.debug(`destination file ${destPath}`);
|
|
yield io.cp(sourceFile, destPath);
|
|
_completeToolPath(tool, version2, arch);
|
|
return destFolder;
|
|
});
|
|
};
|
|
var find = function(toolName, versionSpec, arch) {
|
|
if (!toolName)
|
|
throw new Error("toolName parameter is required");
|
|
if (!versionSpec)
|
|
throw new Error("versionSpec parameter is required");
|
|
arch = arch || os.arch();
|
|
if (!isExplicitVersion(versionSpec)) {
|
|
const localVersions = findAllVersions(toolName, arch);
|
|
const match = evaluateVersions(localVersions, versionSpec);
|
|
versionSpec = match;
|
|
}
|
|
let toolPath = "";
|
|
if (versionSpec) {
|
|
versionSpec = semver.clean(versionSpec) || "";
|
|
const cachePath = path.join(_getCacheDirectory(), toolName, versionSpec, arch);
|
|
core.debug(`checking cache: ${cachePath}`);
|
|
if (fs.existsSync(cachePath) && fs.existsSync(`${cachePath}.complete`)) {
|
|
core.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch}`);
|
|
toolPath = cachePath;
|
|
} else
|
|
core.debug("not found");
|
|
}
|
|
return toolPath;
|
|
};
|
|
var findAllVersions = function(toolName, arch) {
|
|
const versions = [];
|
|
arch = arch || os.arch();
|
|
const toolPath = path.join(_getCacheDirectory(), toolName);
|
|
if (fs.existsSync(toolPath)) {
|
|
const children2 = fs.readdirSync(toolPath);
|
|
for (const child of children2)
|
|
if (isExplicitVersion(child)) {
|
|
const fullPath = path.join(toolPath, child, arch || "");
|
|
if (fs.existsSync(fullPath) && fs.existsSync(`${fullPath}.complete`))
|
|
versions.push(child);
|
|
}
|
|
}
|
|
return versions;
|
|
};
|
|
var getManifestFromRepo = function(owner, repo, auth, branch = "master") {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
let releases = [];
|
|
const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}`;
|
|
const http = new httpm.HttpClient("tool-cache");
|
|
const headers = {};
|
|
if (auth) {
|
|
core.debug("set auth");
|
|
headers.authorization = auth;
|
|
}
|
|
const response = yield http.getJson(treeUrl, headers);
|
|
if (!response.result)
|
|
return releases;
|
|
let manifestUrl = "";
|
|
for (const item of response.result.tree)
|
|
if (item.path === "versions-manifest.json") {
|
|
manifestUrl = item.url;
|
|
break;
|
|
}
|
|
headers["accept"] = "application/vnd.github.VERSION.raw";
|
|
let versionsRaw = yield (yield http.get(manifestUrl, headers)).readBody();
|
|
if (versionsRaw) {
|
|
versionsRaw = versionsRaw.replace(/^\uFEFF/, "");
|
|
try {
|
|
releases = JSON.parse(versionsRaw);
|
|
} catch (_a) {
|
|
core.debug("Invalid json");
|
|
}
|
|
}
|
|
return releases;
|
|
});
|
|
};
|
|
var findFromManifest = function(versionSpec, stable, manifest, archFilter = os.arch()) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter);
|
|
return match;
|
|
});
|
|
};
|
|
var _createExtractFolder = function(dest) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
if (!dest)
|
|
dest = path.join(_getTempDirectory(), v4_1.default());
|
|
yield io.mkdirP(dest);
|
|
return dest;
|
|
});
|
|
};
|
|
var _createToolPath = function(tool, version2, arch) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version2) || version2, arch || "");
|
|
core.debug(`destination ${folderPath}`);
|
|
const markerPath = `${folderPath}.complete`;
|
|
yield io.rmRF(folderPath);
|
|
yield io.rmRF(markerPath);
|
|
yield io.mkdirP(folderPath);
|
|
return folderPath;
|
|
});
|
|
};
|
|
var _completeToolPath = function(tool, version2, arch) {
|
|
const folderPath = path.join(_getCacheDirectory(), tool, semver.clean(version2) || version2, arch || "");
|
|
const markerPath = `${folderPath}.complete`;
|
|
fs.writeFileSync(markerPath, "");
|
|
core.debug("finished caching tool");
|
|
};
|
|
var isExplicitVersion = function(versionSpec) {
|
|
const c = semver.clean(versionSpec) || "";
|
|
core.debug(`isExplicit: ${c}`);
|
|
const valid = semver.valid(c) != null;
|
|
core.debug(`explicit? ${valid}`);
|
|
return valid;
|
|
};
|
|
var evaluateVersions = function(versions, versionSpec) {
|
|
let version2 = "";
|
|
core.debug(`evaluating ${versions.length} versions`);
|
|
versions = versions.sort((a, b) => {
|
|
if (semver.gt(a, b))
|
|
return 1;
|
|
return -1;
|
|
});
|
|
for (let i = versions.length - 1;i >= 0; i--) {
|
|
const potential = versions[i];
|
|
const satisfied = semver.satisfies(potential, versionSpec);
|
|
if (satisfied) {
|
|
version2 = potential;
|
|
break;
|
|
}
|
|
}
|
|
if (version2)
|
|
core.debug(`matched: ${version2}`);
|
|
else
|
|
core.debug("match not found");
|
|
return version2;
|
|
};
|
|
var _getCacheDirectory = function() {
|
|
const cacheDirectory = process.env["RUNNER_TOOL_CACHE"] || "";
|
|
assert_1.ok(cacheDirectory, "Expected RUNNER_TOOL_CACHE to be defined");
|
|
return cacheDirectory;
|
|
};
|
|
var _getTempDirectory = function() {
|
|
const tempDirectory = process.env["RUNNER_TEMP"] || "";
|
|
assert_1.ok(tempDirectory, "Expected RUNNER_TEMP to be defined");
|
|
return tempDirectory;
|
|
};
|
|
var _getGlobal = function(key, defaultValue) {
|
|
const value = global[key];
|
|
return value !== undefined ? value : defaultValue;
|
|
};
|
|
var _unique = function(values) {
|
|
return Array.from(new Set(values));
|
|
};
|
|
var __dirname = "/Users/ashcon/Desktop/code/setup-bun/node_modules/@actions/tool-cache/lib";
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.evaluateVersions = exports.isExplicitVersion = exports.findFromManifest = exports.getManifestFromRepo = exports.findAllVersions = exports.find = exports.cacheFile = exports.cacheDir = exports.extractZip = exports.extractXar = exports.extractTar = exports.extract7z = exports.downloadTool = exports.HTTPError = undefined;
|
|
var core = __importStar(require_core());
|
|
var io = __importStar(require_io());
|
|
var fs = __importStar(__require("fs"));
|
|
var mm = __importStar(require_manifest());
|
|
var os = __importStar(__require("os"));
|
|
var path = __importStar(__require("path"));
|
|
var httpm = __importStar(require_lib());
|
|
var semver = __importStar(require_semver());
|
|
var stream = __importStar(__require("stream"));
|
|
var util = __importStar(__require("util"));
|
|
var assert_1 = __require("assert");
|
|
var v4_1 = __importDefault(require_v4());
|
|
var exec_1 = require_exec();
|
|
var retry_helper_1 = require_retry_helper();
|
|
|
|
class HTTPError extends Error {
|
|
constructor(httpStatusCode) {
|
|
super(`Unexpected HTTP response: ${httpStatusCode}`);
|
|
this.httpStatusCode = httpStatusCode;
|
|
Object.setPrototypeOf(this, new.target.prototype);
|
|
}
|
|
}
|
|
exports.HTTPError = HTTPError;
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
var IS_MAC = process.platform === "darwin";
|
|
var userAgent = "actions/tool-cache";
|
|
exports.downloadTool = downloadTool;
|
|
exports.extract7z = extract7z;
|
|
exports.extractTar = extractTar;
|
|
exports.extractXar = extractXar;
|
|
exports.extractZip = extractZip;
|
|
exports.cacheDir = cacheDir;
|
|
exports.cacheFile = cacheFile;
|
|
exports.find = find;
|
|
exports.findAllVersions = findAllVersions;
|
|
exports.getManifestFromRepo = getManifestFromRepo;
|
|
exports.findFromManifest = findFromManifest;
|
|
exports.isExplicitVersion = isExplicitVersion;
|
|
exports.evaluateVersions = evaluateVersions;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-glob-options-helper.js
|
|
var require_internal_glob_options_helper = __commonJS((exports) => {
|
|
var getOptions = function(copy) {
|
|
const result = {
|
|
followSymbolicLinks: true,
|
|
implicitDescendants: true,
|
|
omitBrokenSymbolicLinks: true
|
|
};
|
|
if (copy) {
|
|
if (typeof copy.followSymbolicLinks === "boolean") {
|
|
result.followSymbolicLinks = copy.followSymbolicLinks;
|
|
core.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`);
|
|
}
|
|
if (typeof copy.implicitDescendants === "boolean") {
|
|
result.implicitDescendants = copy.implicitDescendants;
|
|
core.debug(`implicitDescendants '${result.implicitDescendants}'`);
|
|
}
|
|
if (typeof copy.omitBrokenSymbolicLinks === "boolean") {
|
|
result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks;
|
|
core.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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.getOptions = undefined;
|
|
var core = __importStar(require_core());
|
|
exports.getOptions = getOptions;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-path-helper.js
|
|
var require_internal_path_helper = __commonJS((exports) => {
|
|
var dirname = function(p) {
|
|
p = safeTrimTrailingSeparator(p);
|
|
if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p))
|
|
return p;
|
|
let result = path.dirname(p);
|
|
if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result))
|
|
result = safeTrimTrailingSeparator(result);
|
|
return result;
|
|
};
|
|
var ensureAbsoluteRoot = function(root, itemPath) {
|
|
assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`);
|
|
assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`);
|
|
if (hasAbsoluteRoot(itemPath))
|
|
return itemPath;
|
|
if (IS_WINDOWS) {
|
|
if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) {
|
|
let cwd = process.cwd();
|
|
assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
|
|
if (itemPath[0].toUpperCase() === cwd[0].toUpperCase())
|
|
if (itemPath.length === 2)
|
|
return `${itemPath[0]}:\\${cwd.substr(3)}`;
|
|
else {
|
|
if (!cwd.endsWith("\\"))
|
|
cwd += "\\";
|
|
return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`;
|
|
}
|
|
else
|
|
return `${itemPath[0]}:\\${itemPath.substr(2)}`;
|
|
} else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) {
|
|
const cwd = process.cwd();
|
|
assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
|
|
return `${cwd[0]}:\\${itemPath.substr(1)}`;
|
|
}
|
|
}
|
|
assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`);
|
|
if (root.endsWith("/") || IS_WINDOWS && root.endsWith("\\"))
|
|
;
|
|
else
|
|
root += path.sep;
|
|
return root + itemPath;
|
|
};
|
|
var hasAbsoluteRoot = function(itemPath) {
|
|
assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`);
|
|
itemPath = normalizeSeparators(itemPath);
|
|
if (IS_WINDOWS)
|
|
return itemPath.startsWith("\\\\") || /^[A-Z]:\\/i.test(itemPath);
|
|
return itemPath.startsWith("/");
|
|
};
|
|
var hasRoot = function(itemPath) {
|
|
assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`);
|
|
itemPath = normalizeSeparators(itemPath);
|
|
if (IS_WINDOWS)
|
|
return itemPath.startsWith("\\") || /^[A-Z]:/i.test(itemPath);
|
|
return itemPath.startsWith("/");
|
|
};
|
|
var normalizeSeparators = function(p) {
|
|
p = p || "";
|
|
if (IS_WINDOWS) {
|
|
p = p.replace(/\//g, "\\");
|
|
const isUnc = /^\\\\+[^\\]/.test(p);
|
|
return (isUnc ? "\\" : "") + p.replace(/\\\\+/g, "\\");
|
|
}
|
|
return p.replace(/\/\/+/g, "/");
|
|
};
|
|
var safeTrimTrailingSeparator = function(p) {
|
|
if (!p)
|
|
return "";
|
|
p = normalizeSeparators(p);
|
|
if (!p.endsWith(path.sep))
|
|
return p;
|
|
if (p === path.sep)
|
|
return p;
|
|
if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p))
|
|
return p;
|
|
return p.substr(0, p.length - 1);
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = undefined;
|
|
var path = __importStar(__require("path"));
|
|
var assert_1 = __importDefault(__require("assert"));
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
exports.dirname = dirname;
|
|
exports.ensureAbsoluteRoot = ensureAbsoluteRoot;
|
|
exports.hasAbsoluteRoot = hasAbsoluteRoot;
|
|
exports.hasRoot = hasRoot;
|
|
exports.normalizeSeparators = normalizeSeparators;
|
|
exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-match-kind.js
|
|
var require_internal_match_kind = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.MatchKind = undefined;
|
|
var MatchKind;
|
|
(function(MatchKind2) {
|
|
MatchKind2[MatchKind2["None"] = 0] = "None";
|
|
MatchKind2[MatchKind2["Directory"] = 1] = "Directory";
|
|
MatchKind2[MatchKind2["File"] = 2] = "File";
|
|
MatchKind2[MatchKind2["All"] = 3] = "All";
|
|
})(MatchKind = exports.MatchKind || (exports.MatchKind = {}));
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-pattern-helper.js
|
|
var require_internal_pattern_helper = __commonJS((exports) => {
|
|
var getSearchPaths = function(patterns) {
|
|
patterns = patterns.filter((x) => !x.negate);
|
|
const searchPathMap = {};
|
|
for (const pattern of patterns) {
|
|
const key = IS_WINDOWS ? pattern.searchPath.toUpperCase() : pattern.searchPath;
|
|
searchPathMap[key] = "candidate";
|
|
}
|
|
const result = [];
|
|
for (const pattern of patterns) {
|
|
const key = IS_WINDOWS ? pattern.searchPath.toUpperCase() : pattern.searchPath;
|
|
if (searchPathMap[key] === "included")
|
|
continue;
|
|
let foundAncestor = false;
|
|
let tempKey = key;
|
|
let parent = pathHelper.dirname(tempKey);
|
|
while (parent !== tempKey) {
|
|
if (searchPathMap[parent]) {
|
|
foundAncestor = true;
|
|
break;
|
|
}
|
|
tempKey = parent;
|
|
parent = pathHelper.dirname(tempKey);
|
|
}
|
|
if (!foundAncestor) {
|
|
result.push(pattern.searchPath);
|
|
searchPathMap[key] = "included";
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
var match = function(patterns, itemPath) {
|
|
let result = internal_match_kind_1.MatchKind.None;
|
|
for (const pattern of patterns)
|
|
if (pattern.negate)
|
|
result &= ~pattern.match(itemPath);
|
|
else
|
|
result |= pattern.match(itemPath);
|
|
return result;
|
|
};
|
|
var partialMatch = function(patterns, itemPath) {
|
|
return patterns.some((x) => !x.negate && x.partialMatch(itemPath));
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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.partialMatch = exports.match = exports.getSearchPaths = undefined;
|
|
var pathHelper = __importStar(require_internal_path_helper());
|
|
var internal_match_kind_1 = require_internal_match_kind();
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
exports.getSearchPaths = getSearchPaths;
|
|
exports.match = match;
|
|
exports.partialMatch = partialMatch;
|
|
});
|
|
|
|
// node_modules/concat-map/index.js
|
|
var require_concat_map = __commonJS((exports, module) => {
|
|
module.exports = function(xs, fn) {
|
|
var res = [];
|
|
for (var i = 0;i < xs.length; i++) {
|
|
var x = fn(xs[i], i);
|
|
if (isArray(x))
|
|
res.push.apply(res, x);
|
|
else
|
|
res.push(x);
|
|
}
|
|
return res;
|
|
};
|
|
var isArray = Array.isArray || function(xs) {
|
|
return Object.prototype.toString.call(xs) === "[object Array]";
|
|
};
|
|
});
|
|
|
|
// node_modules/balanced-match/index.js
|
|
var require_balanced_match = __commonJS((exports, module) => {
|
|
var balanced = function(a, b, str) {
|
|
if (a instanceof RegExp)
|
|
a = maybeMatch(a, str);
|
|
if (b instanceof RegExp)
|
|
b = maybeMatch(b, str);
|
|
var r = range(a, b, str);
|
|
return r && {
|
|
start: r[0],
|
|
end: r[1],
|
|
pre: str.slice(0, r[0]),
|
|
body: str.slice(r[0] + a.length, r[1]),
|
|
post: str.slice(r[1] + b.length)
|
|
};
|
|
};
|
|
var maybeMatch = function(reg, str) {
|
|
var m = str.match(reg);
|
|
return m ? m[0] : null;
|
|
};
|
|
var range = function(a, b, str) {
|
|
var begs, beg, left, right, result;
|
|
var ai = str.indexOf(a);
|
|
var bi = str.indexOf(b, ai + 1);
|
|
var i = ai;
|
|
if (ai >= 0 && bi > 0) {
|
|
if (a === b)
|
|
return [ai, bi];
|
|
begs = [];
|
|
left = str.length;
|
|
while (i >= 0 && !result) {
|
|
if (i == ai) {
|
|
begs.push(i);
|
|
ai = str.indexOf(a, i + 1);
|
|
} else if (begs.length == 1)
|
|
result = [begs.pop(), bi];
|
|
else {
|
|
beg = begs.pop();
|
|
if (beg < left) {
|
|
left = beg;
|
|
right = bi;
|
|
}
|
|
bi = str.indexOf(b, i + 1);
|
|
}
|
|
i = ai < bi && ai >= 0 ? ai : bi;
|
|
}
|
|
if (begs.length)
|
|
result = [left, right];
|
|
}
|
|
return result;
|
|
};
|
|
module.exports = balanced;
|
|
balanced.range = range;
|
|
});
|
|
|
|
// node_modules/brace-expansion/index.js
|
|
var require_brace_expansion = __commonJS((exports, module) => {
|
|
var numeric = function(str) {
|
|
return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
|
|
};
|
|
var escapeBraces = function(str) {
|
|
return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
|
|
};
|
|
var unescapeBraces = function(str) {
|
|
return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
|
|
};
|
|
var parseCommaParts = function(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;
|
|
};
|
|
var expandTop = function(str) {
|
|
if (!str)
|
|
return [];
|
|
if (str.substr(0, 2) === "{}")
|
|
str = "\\{\\}" + str.substr(2);
|
|
return expand(escapeBraces(str), true).map(unescapeBraces);
|
|
};
|
|
var embrace = function(str) {
|
|
return "{" + str + "}";
|
|
};
|
|
var isPadded = function(el) {
|
|
return /^-?0\d/.test(el);
|
|
};
|
|
var lte = function(i, y) {
|
|
return i <= y;
|
|
};
|
|
var gte = function(i, y) {
|
|
return i >= y;
|
|
};
|
|
var expand = function(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) {
|
|
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) {
|
|
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;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
};
|
|
var concatMap = require_concat_map();
|
|
var balanced = require_balanced_match();
|
|
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";
|
|
});
|
|
|
|
// node_modules/minimatch/minimatch.js
|
|
var require_minimatch = __commonJS((exports, module) => {
|
|
var charSet = function(s) {
|
|
return s.split("").reduce(function(set, c) {
|
|
set[c] = true;
|
|
return set;
|
|
}, {});
|
|
};
|
|
var filter = function(pattern, options) {
|
|
options = options || {};
|
|
return function(p, i, list) {
|
|
return minimatch(p, pattern, options);
|
|
};
|
|
};
|
|
var ext = function(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;
|
|
};
|
|
var minimatch = function(p, pattern, options) {
|
|
assertValidPattern(pattern);
|
|
if (!options)
|
|
options = {};
|
|
if (!options.nocomment && pattern.charAt(0) === "#")
|
|
return false;
|
|
return new Minimatch(pattern, options).match(p);
|
|
};
|
|
var Minimatch = function(pattern, options) {
|
|
if (!(this instanceof Minimatch))
|
|
return new Minimatch(pattern, options);
|
|
assertValidPattern(pattern);
|
|
if (!options)
|
|
options = {};
|
|
pattern = pattern.trim();
|
|
if (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;
|
|
this.make();
|
|
};
|
|
var make = function() {
|
|
var pattern = this.pattern;
|
|
var options = this.options;
|
|
if (!options.nocomment && pattern.charAt(0) === "#") {
|
|
this.comment = true;
|
|
return;
|
|
}
|
|
if (!pattern) {
|
|
this.empty = true;
|
|
return;
|
|
}
|
|
this.parseNegate();
|
|
var set = this.globSet = this.braceExpand();
|
|
if (options.debug)
|
|
this.debug = function debug() {
|
|
console.error.apply(console, arguments);
|
|
};
|
|
this.debug(this.pattern, set);
|
|
set = this.globParts = set.map(function(s) {
|
|
return s.split(slashSplit);
|
|
});
|
|
this.debug(this.pattern, set);
|
|
set = set.map(function(s, si, set2) {
|
|
return s.map(this.parse, this);
|
|
}, this);
|
|
this.debug(this.pattern, set);
|
|
set = set.filter(function(s) {
|
|
return s.indexOf(false) === -1;
|
|
});
|
|
this.debug(this.pattern, set);
|
|
this.set = set;
|
|
};
|
|
var parseNegate = function() {
|
|
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;
|
|
};
|
|
var braceExpand = function(pattern, options) {
|
|
if (!options)
|
|
if (this instanceof Minimatch)
|
|
options = this.options;
|
|
else
|
|
options = {};
|
|
pattern = typeof pattern === "undefined" ? this.pattern : pattern;
|
|
assertValidPattern(pattern);
|
|
if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern))
|
|
return [pattern];
|
|
return expand(pattern);
|
|
};
|
|
var parse3 = function(pattern, isSub) {
|
|
assertValidPattern(pattern);
|
|
var options = this.options;
|
|
if (pattern === "**")
|
|
if (!options.noglobstar)
|
|
return GLOBSTAR;
|
|
else
|
|
pattern = "*";
|
|
if (pattern === "")
|
|
return "";
|
|
var re = "";
|
|
var hasMagic = !!options.nocase;
|
|
var escaping = false;
|
|
var patternListStack = [];
|
|
var negativeLists = [];
|
|
var stateChar;
|
|
var inClass = false;
|
|
var reClassStart = -1;
|
|
var classStart = -1;
|
|
var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
|
|
var self = this;
|
|
function clearStateChar() {
|
|
if (stateChar) {
|
|
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);
|
|
if (escaping && reSpecials[c]) {
|
|
re += "\\" + c;
|
|
escaping = false;
|
|
continue;
|
|
}
|
|
switch (c) {
|
|
case "/":
|
|
return false;
|
|
case "\\":
|
|
clearStateChar();
|
|
escaping = true;
|
|
continue;
|
|
case "?":
|
|
case "*":
|
|
case "+":
|
|
case "@":
|
|
case "!":
|
|
this.debug("%s\t%s %s %j <-- stateChar", pattern, i, re, c);
|
|
if (inClass) {
|
|
this.debug(" in class");
|
|
if (c === "!" && i === classStart + 1)
|
|
c = "^";
|
|
re += c;
|
|
continue;
|
|
}
|
|
self.debug("call clearStateChar %j", stateChar);
|
|
clearStateChar();
|
|
stateChar = c;
|
|
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
|
|
});
|
|
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();
|
|
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;
|
|
case "[":
|
|
clearStateChar();
|
|
if (inClass) {
|
|
re += "\\" + c;
|
|
continue;
|
|
}
|
|
inClass = true;
|
|
classStart = i;
|
|
reClassStart = re.length;
|
|
re += c;
|
|
continue;
|
|
case "]":
|
|
if (i === classStart + 1 || !inClass) {
|
|
re += "\\" + c;
|
|
escaping = false;
|
|
continue;
|
|
}
|
|
var cs = pattern.substring(classStart + 1, i);
|
|
try {
|
|
RegExp("[" + cs + "]");
|
|
} catch (er) {
|
|
var sp = this.parse(cs, SUBPARSE);
|
|
re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
|
|
hasMagic = hasMagic || sp[1];
|
|
inClass = false;
|
|
continue;
|
|
}
|
|
hasMagic = true;
|
|
inClass = false;
|
|
re += c;
|
|
continue;
|
|
default:
|
|
clearStateChar();
|
|
if (escaping)
|
|
escaping = false;
|
|
else if (reSpecials[c] && !(c === "^" && inClass))
|
|
re += "\\";
|
|
re += c;
|
|
}
|
|
}
|
|
if (inClass) {
|
|
cs = pattern.substr(classStart + 1);
|
|
sp = this.parse(cs, SUBPARSE);
|
|
re = re.substr(0, reClassStart) + "\\[" + sp[0];
|
|
hasMagic = hasMagic || sp[1];
|
|
}
|
|
for (pl = patternListStack.pop();pl; pl = patternListStack.pop()) {
|
|
var tail = re.slice(pl.reStart + pl.open.length);
|
|
this.debug("setting tail", re, pl);
|
|
tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
|
|
if (!$2)
|
|
$2 = "\\";
|
|
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;
|
|
}
|
|
clearStateChar();
|
|
if (escaping)
|
|
re += "\\\\";
|
|
var addPatternStart = false;
|
|
switch (re.charAt(0)) {
|
|
case "[":
|
|
case ".":
|
|
case "(":
|
|
addPatternStart = true;
|
|
}
|
|
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;
|
|
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 (re !== "" && hasMagic)
|
|
re = "(?=.)" + re;
|
|
if (addPatternStart)
|
|
re = patternStart + re;
|
|
if (isSub === SUBPARSE)
|
|
return [re, hasMagic];
|
|
if (!hasMagic)
|
|
return globUnescape(pattern);
|
|
var flags = options.nocase ? "i" : "";
|
|
try {
|
|
var regExp = new RegExp("^" + re + "$", flags);
|
|
} catch (er) {
|
|
return new RegExp("$.");
|
|
}
|
|
regExp._glob = pattern;
|
|
regExp._src = re;
|
|
return regExp;
|
|
};
|
|
var makeRe = function() {
|
|
if (this.regexp || this.regexp === false)
|
|
return this.regexp;
|
|
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("|");
|
|
re = "^(?:" + re + ")$";
|
|
if (this.negate)
|
|
re = "^(?!" + re + ").*$";
|
|
try {
|
|
this.regexp = new RegExp(re, flags);
|
|
} catch (ex) {
|
|
this.regexp = false;
|
|
}
|
|
return this.regexp;
|
|
};
|
|
var globUnescape = function(s) {
|
|
return s.replace(/\\(.)/g, "$1");
|
|
};
|
|
var regExpEscape = function(s) {
|
|
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
|
|
};
|
|
module.exports = minimatch;
|
|
minimatch.Minimatch = Minimatch;
|
|
var path = function() {
|
|
try {
|
|
return __require("path");
|
|
} catch (e) {
|
|
}
|
|
}() || {
|
|
sep: "/"
|
|
};
|
|
minimatch.sep = path.sep;
|
|
var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
|
|
var expand = require_brace_expansion();
|
|
var plTypes = {
|
|
"!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
|
|
"?": { open: "(?:", close: ")?" },
|
|
"+": { open: "(?:", close: ")+" },
|
|
"*": { open: "(?:", close: ")*" },
|
|
"@": { open: "(?:", close: ")" }
|
|
};
|
|
var qmark = "[^/]";
|
|
var star = qmark + "*?";
|
|
var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
|
|
var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
|
|
var reSpecials = charSet("().*{}+?[]^$\\!");
|
|
var slashSplit = /\/+/;
|
|
minimatch.filter = filter;
|
|
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;
|
|
};
|
|
Minimatch.prototype.debug = function() {
|
|
};
|
|
Minimatch.prototype.make = make;
|
|
Minimatch.prototype.parseNegate = parseNegate;
|
|
minimatch.braceExpand = function(pattern, options) {
|
|
return braceExpand(pattern, options);
|
|
};
|
|
Minimatch.prototype.braceExpand = braceExpand;
|
|
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");
|
|
};
|
|
Minimatch.prototype.parse = parse3;
|
|
var SUBPARSE = {};
|
|
minimatch.makeRe = function(pattern, options) {
|
|
return new Minimatch(pattern, options || {}).makeRe();
|
|
};
|
|
Minimatch.prototype.makeRe = makeRe;
|
|
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);
|
|
if (this.comment)
|
|
return false;
|
|
if (this.empty)
|
|
return f === "";
|
|
if (f === "/" && partial)
|
|
return true;
|
|
var options = this.options;
|
|
if (path.sep !== "/")
|
|
f = f.split(path.sep).join("/");
|
|
f = f.split(slashSplit);
|
|
this.debug(this.pattern, "split", f);
|
|
var set = this.set;
|
|
this.debug(this.pattern, "set", set);
|
|
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;
|
|
}
|
|
}
|
|
if (options.flipNegate)
|
|
return false;
|
|
return this.negate;
|
|
};
|
|
Minimatch.prototype.matchOne = function(file, pattern, partial) {
|
|
var options = this.options;
|
|
this.debug("matchOne", { this: this, file, 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);
|
|
if (p === false)
|
|
return false;
|
|
if (p === GLOBSTAR) {
|
|
this.debug("GLOBSTAR", [pattern, p, f]);
|
|
var fr = fi;
|
|
var pr = pi + 1;
|
|
if (pr === pl) {
|
|
this.debug("** at the end");
|
|
for (;fi < fl; fi++)
|
|
if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
|
|
return false;
|
|
return true;
|
|
}
|
|
while (fr < fl) {
|
|
var swallowee = file[fr];
|
|
this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
|
|
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
|
|
this.debug("globstar found match!", fr, fl, swallowee);
|
|
return true;
|
|
} else {
|
|
if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
|
|
this.debug("dot detected!", file, fr, pattern, pr);
|
|
break;
|
|
}
|
|
this.debug("globstar swallow a segment, and continue");
|
|
fr++;
|
|
}
|
|
}
|
|
if (partial) {
|
|
this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
|
|
if (fr === fl)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
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;
|
|
}
|
|
if (fi === fl && pi === pl)
|
|
return true;
|
|
else if (fi === fl)
|
|
return partial;
|
|
else if (pi === pl)
|
|
return fi === fl - 1 && file[fi] === "";
|
|
throw new Error("wtf?");
|
|
};
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-path.js
|
|
var require_internal_path = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Path = undefined;
|
|
var path = __importStar(__require("path"));
|
|
var pathHelper = __importStar(require_internal_path_helper());
|
|
var assert_1 = __importDefault(__require("assert"));
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
|
|
class Path {
|
|
constructor(itemPath) {
|
|
this.segments = [];
|
|
if (typeof itemPath === "string") {
|
|
assert_1.default(itemPath, `Parameter 'itemPath' must not be empty`);
|
|
itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
|
|
if (!pathHelper.hasRoot(itemPath))
|
|
this.segments = itemPath.split(path.sep);
|
|
else {
|
|
let remaining = itemPath;
|
|
let dir = pathHelper.dirname(remaining);
|
|
while (dir !== remaining) {
|
|
const basename = path.basename(remaining);
|
|
this.segments.unshift(basename);
|
|
remaining = dir;
|
|
dir = pathHelper.dirname(remaining);
|
|
}
|
|
this.segments.unshift(remaining);
|
|
}
|
|
} else {
|
|
assert_1.default(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
|
|
for (let i = 0;i < itemPath.length; i++) {
|
|
let segment = itemPath[i];
|
|
assert_1.default(segment, `Parameter 'itemPath' must not contain any empty segments`);
|
|
segment = pathHelper.normalizeSeparators(itemPath[i]);
|
|
if (i === 0 && pathHelper.hasRoot(segment)) {
|
|
segment = pathHelper.safeTrimTrailingSeparator(segment);
|
|
assert_1.default(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
|
|
this.segments.push(segment);
|
|
} else {
|
|
assert_1.default(!segment.includes(path.sep), `Parameter 'itemPath' contains unexpected path separators`);
|
|
this.segments.push(segment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
toString() {
|
|
let result = this.segments[0];
|
|
let skipSlash = result.endsWith(path.sep) || IS_WINDOWS && /^[A-Z]:$/i.test(result);
|
|
for (let i = 1;i < this.segments.length; i++) {
|
|
if (skipSlash)
|
|
skipSlash = false;
|
|
else
|
|
result += path.sep;
|
|
result += this.segments[i];
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
exports.Path = Path;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-pattern.js
|
|
var require_internal_pattern = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 __importDefault = exports && exports.__importDefault || function(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.Pattern = undefined;
|
|
var os = __importStar(__require("os"));
|
|
var path = __importStar(__require("path"));
|
|
var pathHelper = __importStar(require_internal_path_helper());
|
|
var assert_1 = __importDefault(__require("assert"));
|
|
var minimatch_1 = require_minimatch();
|
|
var internal_match_kind_1 = require_internal_match_kind();
|
|
var internal_path_1 = require_internal_path();
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
|
|
class Pattern {
|
|
constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
|
|
this.negate = false;
|
|
let pattern;
|
|
if (typeof patternOrNegate === "string")
|
|
pattern = patternOrNegate.trim();
|
|
else {
|
|
segments = segments || [];
|
|
assert_1.default(segments.length, `Parameter 'segments' must not empty`);
|
|
const root = Pattern.getLiteral(segments[0]);
|
|
assert_1.default(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
|
|
pattern = new internal_path_1.Path(segments).toString().trim();
|
|
if (patternOrNegate)
|
|
pattern = `!${pattern}`;
|
|
}
|
|
while (pattern.startsWith("!")) {
|
|
this.negate = !this.negate;
|
|
pattern = pattern.substr(1).trim();
|
|
}
|
|
pattern = Pattern.fixupPattern(pattern, homedir);
|
|
this.segments = new internal_path_1.Path(pattern).segments;
|
|
this.trailingSeparator = pathHelper.normalizeSeparators(pattern).endsWith(path.sep);
|
|
pattern = pathHelper.safeTrimTrailingSeparator(pattern);
|
|
let foundGlob = false;
|
|
const searchSegments = this.segments.map((x) => Pattern.getLiteral(x)).filter((x) => !foundGlob && !(foundGlob = x === ""));
|
|
this.searchPath = new internal_path_1.Path(searchSegments).toString();
|
|
this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? "i" : "");
|
|
this.isImplicitPattern = isImplicitPattern;
|
|
const minimatchOptions = {
|
|
dot: true,
|
|
nobrace: true,
|
|
nocase: IS_WINDOWS,
|
|
nocomment: true,
|
|
noext: true,
|
|
nonegate: true
|
|
};
|
|
pattern = IS_WINDOWS ? pattern.replace(/\\/g, "/") : pattern;
|
|
this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions);
|
|
}
|
|
match(itemPath) {
|
|
if (this.segments[this.segments.length - 1] === "**") {
|
|
itemPath = pathHelper.normalizeSeparators(itemPath);
|
|
if (!itemPath.endsWith(path.sep) && this.isImplicitPattern === false)
|
|
itemPath = `${itemPath}${path.sep}`;
|
|
} else
|
|
itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
|
|
if (this.minimatch.match(itemPath))
|
|
return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All;
|
|
return internal_match_kind_1.MatchKind.None;
|
|
}
|
|
partialMatch(itemPath) {
|
|
itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
|
|
if (pathHelper.dirname(itemPath) === itemPath)
|
|
return this.rootRegExp.test(itemPath);
|
|
return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true);
|
|
}
|
|
static globEscape(s) {
|
|
return (IS_WINDOWS ? s : s.replace(/\\/g, "\\\\")).replace(/(\[)(?=[^/]+\])/g, "[[]").replace(/\?/g, "[?]").replace(/\*/g, "[*]");
|
|
}
|
|
static fixupPattern(pattern, homedir) {
|
|
assert_1.default(pattern, "pattern cannot be empty");
|
|
const literalSegments = new internal_path_1.Path(pattern).segments.map((x) => Pattern.getLiteral(x));
|
|
assert_1.default(literalSegments.every((x, i) => (x !== "." || i === 0) && x !== ".."), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
|
|
assert_1.default(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
|
|
pattern = pathHelper.normalizeSeparators(pattern);
|
|
if (pattern === "." || pattern.startsWith(`.${path.sep}`))
|
|
pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1);
|
|
else if (pattern === "~" || pattern.startsWith(`~${path.sep}`)) {
|
|
homedir = homedir || os.homedir();
|
|
assert_1.default(homedir, "Unable to determine HOME directory");
|
|
assert_1.default(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
|
|
pattern = Pattern.globEscape(homedir) + pattern.substr(1);
|
|
} else if (IS_WINDOWS && (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
|
|
let root = pathHelper.ensureAbsoluteRoot("C:\\dummy-root", pattern.substr(0, 2));
|
|
if (pattern.length > 2 && !root.endsWith("\\"))
|
|
root += "\\";
|
|
pattern = Pattern.globEscape(root) + pattern.substr(2);
|
|
} else if (IS_WINDOWS && (pattern === "\\" || pattern.match(/^\\[^\\]/))) {
|
|
let root = pathHelper.ensureAbsoluteRoot("C:\\dummy-root", "\\");
|
|
if (!root.endsWith("\\"))
|
|
root += "\\";
|
|
pattern = Pattern.globEscape(root) + pattern.substr(1);
|
|
} else
|
|
pattern = pathHelper.ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern);
|
|
return pathHelper.normalizeSeparators(pattern);
|
|
}
|
|
static getLiteral(segment) {
|
|
let literal = "";
|
|
for (let i = 0;i < segment.length; i++) {
|
|
const c = segment[i];
|
|
if (c === "\\" && !IS_WINDOWS && i + 1 < segment.length) {
|
|
literal += segment[++i];
|
|
continue;
|
|
} else if (c === "*" || c === "?")
|
|
return "";
|
|
else if (c === "[" && i + 1 < segment.length) {
|
|
let set = "";
|
|
let closed = -1;
|
|
for (let i2 = i + 1;i2 < segment.length; i2++) {
|
|
const c2 = segment[i2];
|
|
if (c2 === "\\" && !IS_WINDOWS && i2 + 1 < segment.length) {
|
|
set += segment[++i2];
|
|
continue;
|
|
} else if (c2 === "]") {
|
|
closed = i2;
|
|
break;
|
|
} else
|
|
set += c2;
|
|
}
|
|
if (closed >= 0) {
|
|
if (set.length > 1)
|
|
return "";
|
|
if (set) {
|
|
literal += set;
|
|
i = closed;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
literal += c;
|
|
}
|
|
return literal;
|
|
}
|
|
static regExpEscape(s) {
|
|
return s.replace(/[[\\^$.|?*+()]/g, "\\$&");
|
|
}
|
|
}
|
|
exports.Pattern = Pattern;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-search-state.js
|
|
var require_internal_search_state = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.SearchState = undefined;
|
|
|
|
class SearchState {
|
|
constructor(path, level) {
|
|
this.path = path;
|
|
this.level = level;
|
|
}
|
|
}
|
|
exports.SearchState = SearchState;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/internal-globber.js
|
|
var require_internal_globber = __commonJS((exports) => {
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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 = exports && exports.__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 = exports && exports.__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(v2) {
|
|
resolve({ value: v2, done: d });
|
|
}, reject);
|
|
}
|
|
};
|
|
var __await = exports && exports.__await || function(v) {
|
|
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|
};
|
|
var __asyncGenerator = exports && exports.__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 = undefined;
|
|
var core = __importStar(require_core());
|
|
var fs = __importStar(__require("fs"));
|
|
var globOptionsHelper = __importStar(require_internal_glob_options_helper());
|
|
var path = __importStar(__require("path"));
|
|
var patternHelper = __importStar(require_internal_pattern_helper());
|
|
var internal_match_kind_1 = require_internal_match_kind();
|
|
var internal_pattern_1 = require_internal_pattern();
|
|
var internal_search_state_1 = require_internal_search_state();
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
|
|
class DefaultGlobber {
|
|
constructor(options) {
|
|
this.patterns = [];
|
|
this.searchPaths = [];
|
|
this.options = globOptionsHelper.getOptions(options);
|
|
}
|
|
getSearchPaths() {
|
|
return this.searchPaths.slice();
|
|
}
|
|
glob() {
|
|
var e_1, _a;
|
|
return __awaiter(this, undefined, undefined, 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() {
|
|
const options = globOptionsHelper.getOptions(this.options);
|
|
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("**")));
|
|
}
|
|
const stack = [];
|
|
for (const searchPath of patternHelper.getSearchPaths(patterns)) {
|
|
core.debug(`Search path '${searchPath}'`);
|
|
try {
|
|
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));
|
|
}
|
|
const traversalChain = [];
|
|
while (stack.length) {
|
|
const item = stack.pop();
|
|
const match = patternHelper.match(patterns, item.path);
|
|
const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
|
|
if (!match && !partialMatch)
|
|
continue;
|
|
const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain));
|
|
if (!stats)
|
|
continue;
|
|
if (stats.isDirectory()) {
|
|
if (match & internal_match_kind_1.MatchKind.Directory)
|
|
yield yield __await(item.path);
|
|
else if (!partialMatch)
|
|
continue;
|
|
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());
|
|
} else if (match & internal_match_kind_1.MatchKind.File)
|
|
yield yield __await(item.path);
|
|
}
|
|
});
|
|
}
|
|
static create(patterns, options) {
|
|
return __awaiter(this, undefined, undefined, 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)
|
|
if (!line || line.startsWith("#"))
|
|
continue;
|
|
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, undefined, undefined, function* () {
|
|
let stats;
|
|
if (options.followSymbolicLinks)
|
|
try {
|
|
stats = yield fs.promises.stat(item.path);
|
|
} catch (err) {
|
|
if (err.code === "ENOENT") {
|
|
if (options.omitBrokenSymbolicLinks) {
|
|
core.debug(`Broken symlink '${item.path}'`);
|
|
return;
|
|
}
|
|
throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
|
|
}
|
|
throw err;
|
|
}
|
|
else
|
|
stats = yield fs.promises.lstat(item.path);
|
|
if (stats.isDirectory() && options.followSymbolicLinks) {
|
|
const realPath = yield fs.promises.realpath(item.path);
|
|
while (traversalChain.length >= item.level)
|
|
traversalChain.pop();
|
|
if (traversalChain.some((x) => x === realPath)) {
|
|
core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
|
|
return;
|
|
}
|
|
traversalChain.push(realPath);
|
|
}
|
|
return stats;
|
|
});
|
|
}
|
|
}
|
|
exports.DefaultGlobber = DefaultGlobber;
|
|
});
|
|
|
|
// node_modules/@actions/cache/node_modules/@actions/glob/lib/glob.js
|
|
var require_glob = __commonJS((exports) => {
|
|
var create = function(patterns, options) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return yield internal_globber_1.DefaultGlobber.create(patterns, options);
|
|
});
|
|
};
|
|
var __awaiter = exports && exports.__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 = undefined;
|
|
var internal_globber_1 = require_internal_globber();
|
|
exports.create = create;
|
|
});
|
|
|
|
// node_modules/uuid/v1.js
|
|
var require_v1 = __commonJS((exports, module) => {
|
|
var v12 = function(options, buf, offset) {
|
|
var i = buf && offset || 0;
|
|
var b = buf || [];
|
|
options = options || {};
|
|
var node = options.node || _nodeId2;
|
|
var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq2;
|
|
if (node == null || clockseq == null) {
|
|
var seedBytes = rng4();
|
|
if (node == null)
|
|
node = _nodeId2 = [
|
|
seedBytes[0] | 1,
|
|
seedBytes[1],
|
|
seedBytes[2],
|
|
seedBytes[3],
|
|
seedBytes[4],
|
|
seedBytes[5]
|
|
];
|
|
if (clockseq == null)
|
|
clockseq = _clockseq2 = (seedBytes[6] << 8 | seedBytes[7]) & 16383;
|
|
}
|
|
var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
|
|
var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs2 + 1;
|
|
var dt = msecs - _lastMSecs2 + (nsecs - _lastNSecs2) / 1e4;
|
|
if (dt < 0 && options.clockseq === undefined)
|
|
clockseq = clockseq + 1 & 16383;
|
|
if ((dt < 0 || msecs > _lastMSecs2) && options.nsecs === undefined)
|
|
nsecs = 0;
|
|
if (nsecs >= 1e4)
|
|
throw new Error("uuid.v1(): Can\'t create more than 10M uuids/sec");
|
|
_lastMSecs2 = msecs;
|
|
_lastNSecs2 = nsecs;
|
|
_clockseq2 = clockseq;
|
|
msecs += 12219292800000;
|
|
var tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
|
|
b[i++] = tl >>> 24 & 255;
|
|
b[i++] = tl >>> 16 & 255;
|
|
b[i++] = tl >>> 8 & 255;
|
|
b[i++] = tl & 255;
|
|
var tmh = msecs / 4294967296 * 1e4 & 268435455;
|
|
b[i++] = tmh >>> 8 & 255;
|
|
b[i++] = tmh & 255;
|
|
b[i++] = tmh >>> 24 & 15 | 16;
|
|
b[i++] = tmh >>> 16 & 255;
|
|
b[i++] = clockseq >>> 8 | 128;
|
|
b[i++] = clockseq & 255;
|
|
for (var n = 0;n < 6; ++n)
|
|
b[i + n] = node[n];
|
|
return buf ? buf : bytesToUuid(b);
|
|
};
|
|
var rng4 = require_rng();
|
|
var bytesToUuid = require_bytesToUuid();
|
|
var _nodeId2;
|
|
var _clockseq2;
|
|
var _lastMSecs2 = 0;
|
|
var _lastNSecs2 = 0;
|
|
module.exports = v12;
|
|
});
|
|
|
|
// node_modules/uuid/index.js
|
|
var require_uuid = __commonJS((exports, module) => {
|
|
var v12 = require_v1();
|
|
var v42 = require_v4();
|
|
var uuid = v42;
|
|
uuid.v1 = v12;
|
|
uuid.v4 = v42;
|
|
module.exports = uuid;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/constants.js
|
|
var require_constants = __commonJS((exports) => {
|
|
exports.TarFilename = undefined;
|
|
exports.SystemTarPathOnWindows = undefined;
|
|
exports.GnuTarPathOnWindows = undefined;
|
|
exports.SocketTimeout = undefined;
|
|
exports.DefaultRetryDelay = undefined;
|
|
exports.DefaultRetryAttempts = undefined;
|
|
exports.ArchiveToolType = undefined;
|
|
exports.CompressionMethod = undefined;
|
|
exports.CacheFilename = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ManifestFilename = exports.TarFilename = exports.SystemTarPathOnWindows = exports.GnuTarPathOnWindows = exports.SocketTimeout = exports.DefaultRetryDelay = exports.DefaultRetryAttempts = exports.ArchiveToolType = exports.CompressionMethod = exports.CacheFilename = undefined;
|
|
var CacheFilename;
|
|
(function(CacheFilename2) {
|
|
CacheFilename2["Gzip"] = "cache.tgz";
|
|
CacheFilename2["Zstd"] = "cache.tzst";
|
|
})(CacheFilename = exports.CacheFilename || (exports.CacheFilename = {}));
|
|
var CompressionMethod;
|
|
(function(CompressionMethod2) {
|
|
CompressionMethod2["Gzip"] = "gzip";
|
|
CompressionMethod2["ZstdWithoutLong"] = "zstd-without-long";
|
|
CompressionMethod2["Zstd"] = "zstd";
|
|
})(CompressionMethod = exports.CompressionMethod || (exports.CompressionMethod = {}));
|
|
var ArchiveToolType;
|
|
(function(ArchiveToolType2) {
|
|
ArchiveToolType2["GNU"] = "gnu";
|
|
ArchiveToolType2["BSD"] = "bsd";
|
|
})(ArchiveToolType = exports.ArchiveToolType || (exports.ArchiveToolType = {}));
|
|
exports.DefaultRetryAttempts = 2;
|
|
exports.DefaultRetryDelay = 5000;
|
|
exports.SocketTimeout = 5000;
|
|
exports.GnuTarPathOnWindows = `${process.env["PROGRAMFILES"]}\\Git\\usr\\bin\\tar.exe`;
|
|
exports.SystemTarPathOnWindows = `${process.env["SYSTEMDRIVE"]}\\Windows\\System32\\tar.exe`;
|
|
exports.TarFilename = "cache.tar";
|
|
exports.ManifestFilename = "manifest.txt";
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/cacheUtils.js
|
|
var require_cacheUtils = __commonJS((exports) => {
|
|
var createTempDirectory = function() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const IS_WINDOWS = process.platform === "win32";
|
|
let tempDirectory = process.env["RUNNER_TEMP"] || "";
|
|
if (!tempDirectory) {
|
|
let baseLocation;
|
|
if (IS_WINDOWS)
|
|
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, (0, uuid_1.v4)());
|
|
yield io.mkdirP(dest);
|
|
return dest;
|
|
});
|
|
};
|
|
var getArchiveFileSizeInBytes = function(filePath) {
|
|
return fs.statSync(filePath).size;
|
|
};
|
|
var resolvePaths = function(patterns) {
|
|
var e_1, _a;
|
|
var _b;
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const paths = [];
|
|
const workspace = (_b = process.env["GITHUB_WORKSPACE"]) !== null && _b !== undefined ? _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}`);
|
|
if (relativeFile === "")
|
|
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;
|
|
});
|
|
};
|
|
var unlinkFile = function(filePath) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
return util.promisify(fs.unlink)(filePath);
|
|
});
|
|
};
|
|
var getVersion = function(app, additionalArgs = []) {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
let versionOutput = "";
|
|
additionalArgs.push("--version");
|
|
core.debug(`Checking ${app} ${additionalArgs.join(" ")}`);
|
|
try {
|
|
yield exec.exec(`${app}`, additionalArgs, {
|
|
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;
|
|
});
|
|
};
|
|
var getCompressionMethod = function() {
|
|
return __awaiter(this, undefined, undefined, function* () {
|
|
const versionOutput = yield getVersion("zstd", ["--quiet"]);
|
|
const version2 = semver.clean(versionOutput);
|
|
core.debug(`zstd version: ${version2}`);
|
|
if (versionOutput === "")
|
|
return constants_1.CompressionMethod.Gzip;
|
|
else
|
|
return constants_1.CompressionMethod.ZstdWithoutLong;
|
|
});
|
|
};
|
|
var getCacheFileName = function(compressionMethod) {
|
|
return compressionMethod === constants_1.CompressionMethod.Gzip ? constants_1.CacheFilename.Gzip : constants_1.CacheFilename.Zstd;
|
|
};
|
|
var getGnuTarPathOnWindows = function() {
|
|
return __awaiter(this, undefined, undefined, 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") : "";
|
|
});
|
|
};
|
|
var assertDefined = function(name, value) {
|
|
if (value === undefined)
|
|
throw Error(`Expected ${name} but value was undefiend`);
|
|
return value;
|
|
};
|
|
var isGhes = function() {
|
|
const ghUrl = new URL(process.env["GITHUB_SERVER_URL"] || "https://github.com");
|
|
return ghUrl.hostname.toUpperCase() !== "GITHUB.COM";
|
|
};
|
|
var __createBinding = exports && exports.__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 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = exports && exports.__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;
|
|
};
|
|
var __awaiter = exports && exports.__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 = exports && exports.__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(v2) {
|
|
resolve({ value: v2, done: d });
|
|
}, reject);
|
|
}
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.isGhes = exports.assertDefined = exports.getGnuTarPathOnWindows = exports.getCacheFileName = exports.getCompressionMethod = exports.unlinkFile = exports.resolvePaths = exports.getArchiveFileSizeInBytes = exports.createTempDirectory = undefined;
|
|
var core = __importStar(require_core());
|
|
var exec = __importStar(require_exec());
|
|
var glob = __importStar(require_glob());
|
|
var io = __importStar(require_io());
|
|
var fs = __importStar(__require("fs"));
|
|
var path = __importStar(__require("path"));
|
|
var semver = __importStar(require_semver());
|
|
var util = __importStar(__require("util"));
|
|
var uuid_1 = require_uuid();
|
|
var constants_1 = require_constants();
|
|
exports.createTempDirectory = createTempDirectory;
|
|
exports.getArchiveFileSizeInBytes = getArchiveFileSizeInBytes;
|
|
exports.resolvePaths = resolvePaths;
|
|
exports.unlinkFile = unlinkFile;
|
|
exports.getCompressionMethod = getCompressionMethod;
|
|
exports.getCacheFileName = getCacheFileName;
|
|
exports.getGnuTarPathOnWindows = getGnuTarPathOnWindows;
|
|
exports.assertDefined = assertDefined;
|
|
exports.isGhes = isGhes;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/rng.js
|
|
import crypto4 from "crypto";
|
|
function rng4() {
|
|
if (poolPtr2 > rnds8Pool2.length - 16) {
|
|
crypto4.randomFillSync(rnds8Pool2);
|
|
poolPtr2 = 0;
|
|
}
|
|
return rnds8Pool2.slice(poolPtr2, poolPtr2 += 16);
|
|
}
|
|
var rnds8Pool2, poolPtr2;
|
|
var init_rng2 = __esm(() => {
|
|
rnds8Pool2 = new Uint8Array(256);
|
|
poolPtr2 = rnds8Pool2.length;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/regex.js
|
|
var regex_default2;
|
|
var init_regex2 = __esm(() => {
|
|
regex_default2 = /^(?:[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;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/validate.js
|
|
var validate5, validate_default2;
|
|
var init_validate2 = __esm(() => {
|
|
init_regex2();
|
|
validate5 = function(uuid) {
|
|
return typeof uuid === "string" && regex_default2.test(uuid);
|
|
};
|
|
validate_default2 = validate5;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/stringify.js
|
|
var stringify5, byteToHex2, stringify_default2;
|
|
var init_stringify2 = __esm(() => {
|
|
init_validate2();
|
|
stringify5 = function(arr, offset = 0) {
|
|
const uuid = (byteToHex2[arr[offset + 0]] + byteToHex2[arr[offset + 1]] + byteToHex2[arr[offset + 2]] + byteToHex2[arr[offset + 3]] + "-" + byteToHex2[arr[offset + 4]] + byteToHex2[arr[offset + 5]] + "-" + byteToHex2[arr[offset + 6]] + byteToHex2[arr[offset + 7]] + "-" + byteToHex2[arr[offset + 8]] + byteToHex2[arr[offset + 9]] + "-" + byteToHex2[arr[offset + 10]] + byteToHex2[arr[offset + 11]] + byteToHex2[arr[offset + 12]] + byteToHex2[arr[offset + 13]] + byteToHex2[arr[offset + 14]] + byteToHex2[arr[offset + 15]]).toLowerCase();
|
|
if (!validate_default2(uuid))
|
|
throw TypeError("Stringified UUID is invalid");
|
|
return uuid;
|
|
};
|
|
byteToHex2 = [];
|
|
for (let i = 0;i < 256; ++i)
|
|
byteToHex2.push((i + 256).toString(16).substr(1));
|
|
stringify_default2 = stringify5;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/v1.js
|
|
var v12, _nodeId2, _clockseq2, _lastMSecs2, _lastNSecs2, v1_default2;
|
|
var init_v12 = __esm(() => {
|
|
init_rng2();
|
|
init_stringify2();
|
|
v12 = function(options, buf, offset) {
|
|
let i = buf && offset || 0;
|
|
const b = buf || new Array(16);
|
|
options = options || {};
|
|
let node = options.node || _nodeId2;
|
|
let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq2;
|
|
if (node == null || clockseq == null) {
|
|
const seedBytes = options.random || (options.rng || rng4)();
|
|
if (node == null)
|
|
node = _nodeId2 = [seedBytes[0] | 1, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
|
|
if (clockseq == null)
|
|
clockseq = _clockseq2 = (seedBytes[6] << 8 | seedBytes[7]) & 16383;
|
|
}
|
|
let msecs = options.msecs !== undefined ? options.msecs : Date.now();
|
|
let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs2 + 1;
|
|
const dt = msecs - _lastMSecs2 + (nsecs - _lastNSecs2) / 1e4;
|
|
if (dt < 0 && options.clockseq === undefined)
|
|
clockseq = clockseq + 1 & 16383;
|
|
if ((dt < 0 || msecs > _lastMSecs2) && options.nsecs === undefined)
|
|
nsecs = 0;
|
|
if (nsecs >= 1e4)
|
|
throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
|
|
_lastMSecs2 = msecs;
|
|
_lastNSecs2 = nsecs;
|
|
_clockseq2 = clockseq;
|
|
msecs += 12219292800000;
|
|
const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
|
|
b[i++] = tl >>> 24 & 255;
|
|
b[i++] = tl >>> 16 & 255;
|
|
b[i++] = tl >>> 8 & 255;
|
|
b[i++] = tl & 255;
|
|
const tmh = msecs / 4294967296 * 1e4 & 268435455;
|
|
b[i++] = tmh >>> 8 & 255;
|
|
b[i++] = tmh & 255;
|
|
b[i++] = tmh >>> 24 & 15 | 16;
|
|
b[i++] = tmh >>> 16 & 255;
|
|
b[i++] = clockseq >>> 8 | 128;
|
|
b[i++] = clockseq & 255;
|
|
for (let n = 0;n < 6; ++n)
|
|
b[i + n] = node[n];
|
|
return buf || stringify_default2(b);
|
|
};
|
|
_lastMSecs2 = 0;
|
|
_lastNSecs2 = 0;
|
|
v1_default2 = v12;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/parse.js
|
|
var parse3, parse_default2;
|
|
var init_parse2 = __esm(() => {
|
|
init_validate2();
|
|
parse3 = function(uuid) {
|
|
if (!validate_default2(uuid))
|
|
throw TypeError("Invalid UUID");
|
|
let v;
|
|
const arr = new Uint8Array(16);
|
|
arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
|
|
arr[1] = v >>> 16 & 255;
|
|
arr[2] = v >>> 8 & 255;
|
|
arr[3] = v & 255;
|
|
arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
|
|
arr[5] = v & 255;
|
|
arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
|
|
arr[7] = v & 255;
|
|
arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
|
|
arr[9] = v & 255;
|
|
arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255;
|
|
arr[11] = v / 4294967296 & 255;
|
|
arr[12] = v >>> 24 & 255;
|
|
arr[13] = v >>> 16 & 255;
|
|
arr[14] = v >>> 8 & 255;
|
|
arr[15] = v & 255;
|
|
return arr;
|
|
};
|
|
parse_default2 = parse3;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/v35.js
|
|
function v35_default2(name, version2, hashfunc) {
|
|
function generateUUID(value, namespace, buf, offset) {
|
|
if (typeof value === "string")
|
|
value = stringToBytes2(value);
|
|
if (typeof namespace === "string")
|
|
namespace = parse_default2(namespace);
|
|
if (namespace.length !== 16)
|
|
throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
|
|
let bytes = new Uint8Array(16 + value.length);
|
|
bytes.set(namespace);
|
|
bytes.set(value, namespace.length);
|
|
bytes = hashfunc(bytes);
|
|
bytes[6] = bytes[6] & 15 | version2;
|
|
bytes[8] = bytes[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
for (let i = 0;i < 16; ++i)
|
|
buf[offset + i] = bytes[i];
|
|
return buf;
|
|
}
|
|
return stringify_default2(bytes);
|
|
}
|
|
try {
|
|
generateUUID.name = name;
|
|
} catch (err) {
|
|
}
|
|
generateUUID.DNS = DNS2;
|
|
generateUUID.URL = URL3;
|
|
return generateUUID;
|
|
}
|
|
var stringToBytes2, DNS2, URL3;
|
|
var init_v352 = __esm(() => {
|
|
init_stringify2();
|
|
init_parse2();
|
|
stringToBytes2 = function(str) {
|
|
str = unescape(encodeURIComponent(str));
|
|
const bytes = [];
|
|
for (let i = 0;i < str.length; ++i)
|
|
bytes.push(str.charCodeAt(i));
|
|
return bytes;
|
|
};
|
|
DNS2 = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
|
|
URL3 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/md5.js
|
|
import crypto5 from "crypto";
|
|
var md53, md5_default2;
|
|
var init_md52 = __esm(() => {
|
|
md53 = function(bytes) {
|
|
if (Array.isArray(bytes))
|
|
bytes = Buffer.from(bytes);
|
|
else if (typeof bytes === "string")
|
|
bytes = Buffer.from(bytes, "utf8");
|
|
return crypto5.createHash("md5").update(bytes).digest();
|
|
};
|
|
md5_default2 = md53;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/v3.js
|
|
var v32, v3_default2;
|
|
var init_v32 = __esm(() => {
|
|
init_v352();
|
|
init_md52();
|
|
v32 = v35_default2("v3", 48, md5_default2);
|
|
v3_default2 = v32;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/v4.js
|
|
var v42, v4_default2;
|
|
var init_v42 = __esm(() => {
|
|
init_rng2();
|
|
init_stringify2();
|
|
v42 = function(options, buf, offset) {
|
|
options = options || {};
|
|
const rnds = options.random || (options.rng || rng4)();
|
|
rnds[6] = rnds[6] & 15 | 64;
|
|
rnds[8] = rnds[8] & 63 | 128;
|
|
if (buf) {
|
|
offset = offset || 0;
|
|
for (let i = 0;i < 16; ++i)
|
|
buf[offset + i] = rnds[i];
|
|
return buf;
|
|
}
|
|
return stringify_default2(rnds);
|
|
};
|
|
v4_default2 = v42;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/sha1.js
|
|
import crypto6 from "crypto";
|
|
var sha13, sha1_default2;
|
|
var init_sha12 = __esm(() => {
|
|
sha13 = function(bytes) {
|
|
if (Array.isArray(bytes))
|
|
bytes = Buffer.from(bytes);
|
|
else if (typeof bytes === "string")
|
|
bytes = Buffer.from(bytes, "utf8");
|
|
return crypto6.createHash("sha1").update(bytes).digest();
|
|
};
|
|
sha1_default2 = sha13;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/v5.js
|
|
var v52, v5_default2;
|
|
var init_v52 = __esm(() => {
|
|
init_v352();
|
|
init_sha12();
|
|
v52 = v35_default2("v5", 80, sha1_default2);
|
|
v5_default2 = v52;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/nil.js
|
|
var nil_default2;
|
|
var init_nil2 = __esm(() => {
|
|
nil_default2 = "00000000-0000-0000-0000-000000000000";
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/version.js
|
|
var version2, version_default2;
|
|
var init_version2 = __esm(() => {
|
|
init_validate2();
|
|
version2 = function(uuid) {
|
|
if (!validate_default2(uuid))
|
|
throw TypeError("Invalid UUID");
|
|
return parseInt(uuid.substr(14, 1), 16);
|
|
};
|
|
version_default2 = version2;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/uuid/dist/esm-node/index.js
|
|
var exports_esm_node2 = {};
|
|
__export(exports_esm_node2, {
|
|
version: () => {
|
|
{
|
|
return version_default2;
|
|
}
|
|
},
|
|
validate: () => {
|
|
{
|
|
return validate_default2;
|
|
}
|
|
},
|
|
v5: () => {
|
|
{
|
|
return v5_default2;
|
|
}
|
|
},
|
|
v4: () => {
|
|
{
|
|
return v4_default2;
|
|
}
|
|
},
|
|
v3: () => {
|
|
{
|
|
return v3_default2;
|
|
}
|
|
},
|
|
v1: () => {
|
|
{
|
|
return v1_default2;
|
|
}
|
|
},
|
|
stringify: () => {
|
|
{
|
|
return stringify_default2;
|
|
}
|
|
},
|
|
parse: () => {
|
|
{
|
|
return parse_default2;
|
|
}
|
|
},
|
|
NIL: () => {
|
|
{
|
|
return nil_default2;
|
|
}
|
|
}
|
|
});
|
|
var init_esm_node2 = __esm(() => {
|
|
});
|
|
|
|
// node_modules/tslib/tslib.es6.js
|
|
var exports_tslib_es6 = {};
|
|
__export(exports_tslib_es6, {
|
|
__values: () => {
|
|
{
|
|
return __values2;
|
|
}
|
|
},
|
|
__spreadArrays: () => {
|
|
{
|
|
return __spreadArrays;
|
|
}
|
|
},
|
|
__spreadArray: () => {
|
|
{
|
|
return __spreadArray;
|
|
}
|
|
},
|
|
__spread: () => {
|
|
{
|
|
return __spread;
|
|
}
|
|
},
|
|
__setFunctionName: () => {
|
|
{
|
|
return __setFunctionName;
|
|
}
|
|
},
|
|
__runInitializers: () => {
|
|
{
|
|
return __runInitializers;
|
|
}
|
|
},
|
|
__rest: () => {
|
|
{
|
|
return __rest;
|
|
}
|
|
},
|
|
__read: () => {
|
|
{
|
|
return __read;
|
|
}
|
|
},
|
|
__propKey: () => {
|
|
{
|
|
return __propKey;
|
|
}
|
|
},
|
|
__param: () => {
|
|
{
|
|
return __param;
|
|
}
|
|
},
|
|
__metadata: () => {
|
|
{
|
|
return __metadata;
|
|
}
|
|
},
|
|
__makeTemplateObject: () => {
|
|
{
|
|
return __makeTemplateObject;
|
|
}
|
|
},
|
|
__importStar: () => {
|
|
{
|
|
return __importStar;
|
|
}
|
|
},
|
|
__importDefault: () => {
|
|
{
|
|
return __importDefault;
|
|
}
|
|
},
|
|
__generator: () => {
|
|
{
|
|
return __generator;
|
|
}
|
|
},
|
|
__extends: () => {
|
|
{
|
|
return __extends;
|
|
}
|
|
},
|
|
__exportStar: () => {
|
|
{
|
|
return __exportStar;
|
|
}
|
|
},
|
|
__esDecorate: () => {
|
|
{
|
|
return __esDecorate;
|
|
}
|
|
},
|
|
__decorate: () => {
|
|
{
|
|
return __decorate;
|
|
}
|
|
},
|
|
__createBinding: () => {
|
|
{
|
|
return __createBinding;
|
|
}
|
|
},
|
|
__classPrivateFieldSet: () => {
|
|
{
|
|
return __classPrivateFieldSet;
|
|
}
|
|
},
|
|
__classPrivateFieldIn: () => {
|
|
{
|
|
return __classPrivateFieldIn;
|
|
}
|
|
},
|
|
__classPrivateFieldGet: () => {
|
|
{
|
|
return __classPrivateFieldGet;
|
|
}
|
|
},
|
|
__awaiter: () => {
|
|
{
|
|
return __awaiter;
|
|
}
|
|
},
|
|
__await: () => {
|
|
{
|
|
return __await;
|
|
}
|
|
},
|
|
__asyncValues: () => {
|
|
{
|
|
return __asyncValues;
|
|
}
|
|
},
|
|
__asyncGenerator: () => {
|
|
{
|
|
return __asyncGenerator;
|
|
}
|
|
},
|
|
__asyncDelegator: () => {
|
|
{
|
|
return __asyncDelegator;
|
|
}
|
|
},
|
|
__assign: () => {
|
|
{
|
|
return __assign;
|
|
}
|
|
}
|
|
});
|
|
function __extends(d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() {
|
|
this.constructor = d;
|
|
}
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __);
|
|
}
|
|
function __rest(s, e) {
|
|
var t = {};
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
|
t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function") {
|
|
for (var i = 0, p = Object.getOwnPropertySymbols(s);i < p.length; i++)
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
|
t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
}
|
|
function __decorate(decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
|
|
r = Reflect.decorate(decorators, target, key, desc);
|
|
else
|
|
for (var i = decorators.length - 1;i >= 0; i--)
|
|
if (d = decorators[i])
|
|
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
}
|
|
function __param(paramIndex, decorator) {
|
|
return function(target, key) {
|
|
decorator(target, key, paramIndex);
|
|
};
|
|
}
|
|
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
|
function accept(f) {
|
|
if (f !== undefined && typeof f !== "function")
|
|
throw new TypeError("Function expected");
|
|
return f;
|
|
}
|
|
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
|
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
|
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
|
var _, done = false;
|
|
for (var i = decorators.length - 1;i >= 0; i--) {
|
|
var context = {};
|
|
for (var p in contextIn)
|
|
context[p] = p === "access" ? {} : contextIn[p];
|
|
for (var p in contextIn.access)
|
|
context.access[p] = contextIn.access[p];
|
|
context.addInitializer = function(f) {
|
|
if (done)
|
|
throw new TypeError("Cannot add initializers after decoration has completed");
|
|
extraInitializers.push(accept(f || null));
|
|
};
|
|
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
|
if (kind === "accessor") {
|
|
if (result === undefined)
|
|
continue;
|
|
if (result === null || typeof result !== "object")
|
|
throw new TypeError("Object expected");
|
|
if (_ = accept(result.get))
|
|
descriptor.get = _;
|
|
if (_ = accept(result.set))
|
|
descriptor.set = _;
|
|
if (_ = accept(result.init))
|
|
initializers.push(_);
|
|
} else if (_ = accept(result))
|
|
if (kind === "field")
|
|
initializers.push(_);
|
|
else
|
|
descriptor[key] = _;
|
|
}
|
|
if (target)
|
|
Object.defineProperty(target, contextIn.name, descriptor);
|
|
done = true;
|
|
}
|
|
function __runInitializers(thisArg, initializers, value) {
|
|
var useValue = arguments.length > 2;
|
|
for (var i = 0;i < initializers.length; i++)
|
|
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
|
return useValue ? value : undefined;
|
|
}
|
|
function __propKey(x) {
|
|
return typeof x === "symbol" ? x : "".concat(x);
|
|
}
|
|
function __setFunctionName(f, name, prefix) {
|
|
if (typeof name === "symbol")
|
|
name = name.description ? "[".concat(name.description, "]") : "";
|
|
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
|
}
|
|
function __metadata(metadataKey, metadataValue) {
|
|
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
|
|
return Reflect.metadata(metadataKey, metadataValue);
|
|
}
|
|
function __awaiter(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());
|
|
});
|
|
}
|
|
function __generator(thisArg, body) {
|
|
var _ = { label: 0, sent: function() {
|
|
if (t[0] & 1)
|
|
throw t[1];
|
|
return t[1];
|
|
}, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), throw: verb(1), return: verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
|
|
return this;
|
|
}), g;
|
|
function verb(n) {
|
|
return function(v) {
|
|
return step([n, v]);
|
|
};
|
|
}
|
|
function step(op) {
|
|
if (f)
|
|
throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _)
|
|
try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
|
|
return t;
|
|
if (y = 0, t)
|
|
op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return { value: op[1], done: false };
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [0];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2])
|
|
_.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) {
|
|
op = [6, e];
|
|
y = 0;
|
|
} finally {
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5)
|
|
throw op[1];
|
|
return { value: op[0] ? op[1] : undefined, done: true };
|
|
}
|
|
}
|
|
function __exportStar(m, o) {
|
|
for (var p in m)
|
|
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
|
|
__createBinding(o, m, p);
|
|
}
|
|
function __values2(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m)
|
|
return m.call(o);
|
|
if (o && typeof o.length === "number")
|
|
return {
|
|
next: function() {
|
|
if (o && i >= o.length)
|
|
o = undefined;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
}
|
|
function __read(o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m)
|
|
return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === undefined || n-- > 0) && !(r = i.next()).done)
|
|
ar.push(r.value);
|
|
} catch (error) {
|
|
e = { error };
|
|
} finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"]))
|
|
m.call(i);
|
|
} finally {
|
|
if (e)
|
|
throw e.error;
|
|
}
|
|
}
|
|
return ar;
|
|
}
|
|
function __spread() {
|
|
for (var ar = [], i = 0;i < arguments.length; i++)
|
|
ar = ar.concat(__read(arguments[i]));
|
|
return ar;
|
|
}
|
|
function __spreadArrays() {
|
|
for (var s = 0, i = 0, il = arguments.length;i < il; i++)
|
|
s += arguments[i].length;
|
|
for (var r = Array(s), k = 0, i = 0;i < il; i++)
|
|
for (var a = arguments[i], j = 0, jl = a.length;j < jl; j++, k++)
|
|
r[k] = a[j];
|
|
return r;
|
|
}
|
|
function __spreadArray(to, from, pack) {
|
|
if (pack || arguments.length === 2) {
|
|
for (var i = 0, l = from.length, ar;i < l; i++)
|
|
if (ar || !(i in from)) {
|
|
if (!ar)
|
|
ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
}
|
|
function __await(v) {
|
|
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|
}
|
|
function __asyncGenerator(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]);
|
|
}
|
|
}
|
|
function __asyncDelegator(o) {
|
|
var i, p;
|
|
return i = {}, verb("next"), verb("throw", function(e) {
|
|
throw e;
|
|
}), verb("return"), i[Symbol.iterator] = function() {
|
|
return this;
|
|
}, i;
|
|
function verb(n, f) {
|
|
i[n] = o[n] ? function(v) {
|
|
return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
|
|
} : f;
|
|
}
|
|
}
|
|
function __asyncValues(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 __values2 === "function" ? __values2(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(v2) {
|
|
resolve({ value: v2, done: d });
|
|
}, reject);
|
|
}
|
|
}
|
|
function __makeTemplateObject(cooked, raw) {
|
|
if (Object.defineProperty)
|
|
Object.defineProperty(cooked, "raw", { value: raw });
|
|
else
|
|
cooked.raw = raw;
|
|
return cooked;
|
|
}
|
|
function __importStar(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;
|
|
}
|
|
function __importDefault(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
}
|
|
function __classPrivateFieldGet(receiver, state, kind, f) {
|
|
if (kind === "a" && !f)
|
|
throw new TypeError("Private accessor was defined without a getter");
|
|
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
|
|
throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
|
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
|
}
|
|
function __classPrivateFieldSet(receiver, state, value, kind, f) {
|
|
if (kind === "m")
|
|
throw new TypeError("Private method is not writable");
|
|
if (kind === "a" && !f)
|
|
throw new TypeError("Private accessor was defined without a setter");
|
|
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
|
|
throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
|
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
|
|
}
|
|
function __classPrivateFieldIn(state, receiver) {
|
|
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
|
|
throw new TypeError("Cannot use 'in' operator on non-object");
|
|
return typeof state === "function" ? receiver === state : state.has(receiver);
|
|
}
|
|
var extendStatics, __assign, __createBinding, __setModuleDefault;
|
|
var init_tslib_es6 = __esm(() => {
|
|
extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
|
|
d2.__proto__ = b2;
|
|
} || function(d2, b2) {
|
|
for (var p in b2)
|
|
if (Object.prototype.hasOwnProperty.call(b2, p))
|
|
d2[p] = b2[p];
|
|
};
|
|
return extendStatics(d, b);
|
|
};
|
|
__assign = function() {
|
|
__assign = Object.assign || function __assign(t) {
|
|
for (var s, i = 1, n = arguments.length;i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
__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];
|
|
};
|
|
__setModuleDefault = Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
};
|
|
});
|
|
|
|
// node_modules/xml2js/lib/defaults.js
|
|
var require_defaults = __commonJS((exports) => {
|
|
(function() {
|
|
exports.defaults = {
|
|
"0.1": {
|
|
explicitCharkey: false,
|
|
trim: true,
|
|
normalize: true,
|
|
normalizeTags: false,
|
|
attrkey: "@",
|
|
charkey: "#",
|
|
explicitArray: false,
|
|
ignoreAttrs: false,
|
|
mergeAttrs: false,
|
|
explicitRoot: false,
|
|
validator: null,
|
|
xmlns: false,
|
|
explicitChildren: false,
|
|
childkey: "@@",
|
|
charsAsChildren: false,
|
|
includeWhiteChars: false,
|
|
async: false,
|
|
strict: true,
|
|
attrNameProcessors: null,
|
|
attrValueProcessors: null,
|
|
tagNameProcessors: null,
|
|
valueProcessors: null,
|
|
emptyTag: ""
|
|
},
|
|
"0.2": {
|
|
explicitCharkey: false,
|
|
trim: false,
|
|
normalize: false,
|
|
normalizeTags: false,
|
|
attrkey: "$",
|
|
charkey: "_",
|
|
explicitArray: true,
|
|
ignoreAttrs: false,
|
|
mergeAttrs: false,
|
|
explicitRoot: true,
|
|
validator: null,
|
|
xmlns: false,
|
|
explicitChildren: false,
|
|
preserveChildrenOrder: false,
|
|
childkey: "$$",
|
|
charsAsChildren: false,
|
|
includeWhiteChars: false,
|
|
async: false,
|
|
strict: true,
|
|
attrNameProcessors: null,
|
|
attrValueProcessors: null,
|
|
tagNameProcessors: null,
|
|
valueProcessors: null,
|
|
rootName: "root",
|
|
xmldec: {
|
|
version: "1.0",
|
|
encoding: "UTF-8",
|
|
standalone: true
|
|
},
|
|
doctype: null,
|
|
renderOpts: {
|
|
pretty: true,
|
|
indent: " ",
|
|
newline: "\n"
|
|
},
|
|
headless: false,
|
|
chunkSize: 1e4,
|
|
emptyTag: "",
|
|
cdata: false
|
|
}
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/Utility.js
|
|
var require_Utility = __commonJS((exports, module) => {
|
|
(function() {
|
|
var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject, slice = [].slice, hasProp = {}.hasOwnProperty;
|
|
assign = function() {
|
|
var i, key, len, source, sources, target;
|
|
target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
|
|
if (isFunction(Object.assign))
|
|
Object.assign.apply(null, arguments);
|
|
else
|
|
for (i = 0, len = sources.length;i < len; i++) {
|
|
source = sources[i];
|
|
if (source != null)
|
|
for (key in source) {
|
|
if (!hasProp.call(source, key))
|
|
continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
isFunction = function(val) {
|
|
return !!val && Object.prototype.toString.call(val) === "[object Function]";
|
|
};
|
|
isObject = function(val) {
|
|
var ref;
|
|
return !!val && ((ref = typeof val) === "function" || ref === "object");
|
|
};
|
|
isArray = function(val) {
|
|
if (isFunction(Array.isArray))
|
|
return Array.isArray(val);
|
|
else
|
|
return Object.prototype.toString.call(val) === "[object Array]";
|
|
};
|
|
isEmpty = function(val) {
|
|
var key;
|
|
if (isArray(val))
|
|
return !val.length;
|
|
else {
|
|
for (key in val) {
|
|
if (!hasProp.call(val, key))
|
|
continue;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
isPlainObject = function(val) {
|
|
var ctor, proto;
|
|
return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
|
|
};
|
|
getValue = function(obj) {
|
|
if (isFunction(obj.valueOf))
|
|
return obj.valueOf();
|
|
else
|
|
return obj;
|
|
};
|
|
exports.assign = assign;
|
|
exports.isFunction = isFunction;
|
|
exports.isObject = isObject;
|
|
exports.isArray = isArray;
|
|
exports.isEmpty = isEmpty;
|
|
exports.isPlainObject = isPlainObject;
|
|
exports.getValue = getValue;
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDOMImplementation.js
|
|
var require_XMLDOMImplementation = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLDOMImplementation;
|
|
module.exports = XMLDOMImplementation = function() {
|
|
function XMLDOMImplementation2() {
|
|
}
|
|
XMLDOMImplementation2.prototype.hasFeature = function(feature, version3) {
|
|
return true;
|
|
};
|
|
XMLDOMImplementation2.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
XMLDOMImplementation2.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
XMLDOMImplementation2.prototype.createHTMLDocument = function(title) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
XMLDOMImplementation2.prototype.getFeature = function(feature, version3) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
return XMLDOMImplementation2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js
|
|
var require_XMLDOMErrorHandler = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLDOMErrorHandler;
|
|
module.exports = XMLDOMErrorHandler = function() {
|
|
function XMLDOMErrorHandler2() {
|
|
}
|
|
XMLDOMErrorHandler2.prototype.handleError = function(error) {
|
|
throw new Error(error);
|
|
};
|
|
return XMLDOMErrorHandler2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDOMStringList.js
|
|
var require_XMLDOMStringList = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLDOMStringList;
|
|
module.exports = XMLDOMStringList = function() {
|
|
function XMLDOMStringList2(arr) {
|
|
this.arr = arr || [];
|
|
}
|
|
Object.defineProperty(XMLDOMStringList2.prototype, "length", {
|
|
get: function() {
|
|
return this.arr.length;
|
|
}
|
|
});
|
|
XMLDOMStringList2.prototype.item = function(index) {
|
|
return this.arr[index] || null;
|
|
};
|
|
XMLDOMStringList2.prototype.contains = function(str) {
|
|
return this.arr.indexOf(str) !== -1;
|
|
};
|
|
return XMLDOMStringList2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDOMConfiguration.js
|
|
var require_XMLDOMConfiguration = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
|
|
XMLDOMErrorHandler = require_XMLDOMErrorHandler();
|
|
XMLDOMStringList = require_XMLDOMStringList();
|
|
module.exports = XMLDOMConfiguration = function() {
|
|
function XMLDOMConfiguration2() {
|
|
var clonedSelf;
|
|
this.defaultParams = {
|
|
"canonical-form": false,
|
|
"cdata-sections": false,
|
|
comments: false,
|
|
"datatype-normalization": false,
|
|
"element-content-whitespace": true,
|
|
entities: true,
|
|
"error-handler": new XMLDOMErrorHandler,
|
|
infoset: true,
|
|
"validate-if-schema": false,
|
|
namespaces: true,
|
|
"namespace-declarations": true,
|
|
"normalize-characters": false,
|
|
"schema-location": "",
|
|
"schema-type": "",
|
|
"split-cdata-sections": true,
|
|
validate: false,
|
|
"well-formed": true
|
|
};
|
|
this.params = clonedSelf = Object.create(this.defaultParams);
|
|
}
|
|
Object.defineProperty(XMLDOMConfiguration2.prototype, "parameterNames", {
|
|
get: function() {
|
|
return new XMLDOMStringList(Object.keys(this.defaultParams));
|
|
}
|
|
});
|
|
XMLDOMConfiguration2.prototype.getParameter = function(name) {
|
|
if (this.params.hasOwnProperty(name))
|
|
return this.params[name];
|
|
else
|
|
return null;
|
|
};
|
|
XMLDOMConfiguration2.prototype.canSetParameter = function(name, value) {
|
|
return true;
|
|
};
|
|
XMLDOMConfiguration2.prototype.setParameter = function(name, value) {
|
|
if (value != null)
|
|
return this.params[name] = value;
|
|
else
|
|
return delete this.params[name];
|
|
};
|
|
return XMLDOMConfiguration2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/NodeType.js
|
|
var require_NodeType = __commonJS((exports, module) => {
|
|
(function() {
|
|
module.exports = {
|
|
Element: 1,
|
|
Attribute: 2,
|
|
Text: 3,
|
|
CData: 4,
|
|
EntityReference: 5,
|
|
EntityDeclaration: 6,
|
|
ProcessingInstruction: 7,
|
|
Comment: 8,
|
|
Document: 9,
|
|
DocType: 10,
|
|
DocumentFragment: 11,
|
|
NotationDeclaration: 12,
|
|
Declaration: 201,
|
|
Raw: 202,
|
|
AttributeDeclaration: 203,
|
|
ElementDeclaration: 204,
|
|
Dummy: 205
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLAttribute.js
|
|
var require_XMLAttribute = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLAttribute, XMLNode;
|
|
NodeType = require_NodeType();
|
|
XMLNode = require_XMLNode();
|
|
module.exports = XMLAttribute = function() {
|
|
function XMLAttribute2(parent, name, value) {
|
|
this.parent = parent;
|
|
if (this.parent) {
|
|
this.options = this.parent.options;
|
|
this.stringify = this.parent.stringify;
|
|
}
|
|
if (name == null)
|
|
throw new Error("Missing attribute name. " + this.debugInfo(name));
|
|
this.name = this.stringify.name(name);
|
|
this.value = this.stringify.attValue(value);
|
|
this.type = NodeType.Attribute;
|
|
this.isId = false;
|
|
this.schemaTypeInfo = null;
|
|
}
|
|
Object.defineProperty(XMLAttribute2.prototype, "nodeType", {
|
|
get: function() {
|
|
return this.type;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "ownerElement", {
|
|
get: function() {
|
|
return this.parent;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "textContent", {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "namespaceURI", {
|
|
get: function() {
|
|
return "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "prefix", {
|
|
get: function() {
|
|
return "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "localName", {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLAttribute2.prototype, "specified", {
|
|
get: function() {
|
|
return true;
|
|
}
|
|
});
|
|
XMLAttribute2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLAttribute2.prototype.toString = function(options) {
|
|
return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLAttribute2.prototype.debugInfo = function(name) {
|
|
name = name || this.name;
|
|
if (name == null)
|
|
return "parent: <" + this.parent.name + ">";
|
|
else
|
|
return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
|
|
};
|
|
XMLAttribute2.prototype.isEqualNode = function(node) {
|
|
if (node.namespaceURI !== this.namespaceURI)
|
|
return false;
|
|
if (node.prefix !== this.prefix)
|
|
return false;
|
|
if (node.localName !== this.localName)
|
|
return false;
|
|
if (node.value !== this.value)
|
|
return false;
|
|
return true;
|
|
};
|
|
return XMLAttribute2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLNamedNodeMap.js
|
|
var require_XMLNamedNodeMap = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLNamedNodeMap;
|
|
module.exports = XMLNamedNodeMap = function() {
|
|
function XMLNamedNodeMap2(nodes) {
|
|
this.nodes = nodes;
|
|
}
|
|
Object.defineProperty(XMLNamedNodeMap2.prototype, "length", {
|
|
get: function() {
|
|
return Object.keys(this.nodes).length || 0;
|
|
}
|
|
});
|
|
XMLNamedNodeMap2.prototype.clone = function() {
|
|
return this.nodes = null;
|
|
};
|
|
XMLNamedNodeMap2.prototype.getNamedItem = function(name) {
|
|
return this.nodes[name];
|
|
};
|
|
XMLNamedNodeMap2.prototype.setNamedItem = function(node) {
|
|
var oldNode;
|
|
oldNode = this.nodes[node.nodeName];
|
|
this.nodes[node.nodeName] = node;
|
|
return oldNode || null;
|
|
};
|
|
XMLNamedNodeMap2.prototype.removeNamedItem = function(name) {
|
|
var oldNode;
|
|
oldNode = this.nodes[name];
|
|
delete this.nodes[name];
|
|
return oldNode || null;
|
|
};
|
|
XMLNamedNodeMap2.prototype.item = function(index) {
|
|
return this.nodes[Object.keys(this.nodes)[index]] || null;
|
|
};
|
|
XMLNamedNodeMap2.prototype.getNamedItemNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
XMLNamedNodeMap2.prototype.setNamedItemNS = function(node) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
XMLNamedNodeMap2.prototype.removeNamedItemNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented.");
|
|
};
|
|
return XMLNamedNodeMap2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLElement.js
|
|
var require_XMLElement = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref, 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;
|
|
ref = require_Utility(), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;
|
|
XMLNode = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
XMLAttribute = require_XMLAttribute();
|
|
XMLNamedNodeMap = require_XMLNamedNodeMap();
|
|
module.exports = XMLElement = function(superClass) {
|
|
extend(XMLElement2, superClass);
|
|
function XMLElement2(parent, name, attributes) {
|
|
var child, j, len, ref1;
|
|
XMLElement2.__super__.constructor.call(this, parent);
|
|
if (name == null)
|
|
throw new Error("Missing element name. " + this.debugInfo());
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.Element;
|
|
this.attribs = {};
|
|
this.schemaTypeInfo = null;
|
|
if (attributes != null)
|
|
this.attribute(attributes);
|
|
if (parent.type === NodeType.Document) {
|
|
this.isRoot = true;
|
|
this.documentObject = parent;
|
|
parent.rootObject = this;
|
|
if (parent.children) {
|
|
ref1 = parent.children;
|
|
for (j = 0, len = ref1.length;j < len; j++) {
|
|
child = ref1[j];
|
|
if (child.type === NodeType.DocType) {
|
|
child.name = this.name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperty(XMLElement2.prototype, "tagName", {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "namespaceURI", {
|
|
get: function() {
|
|
return "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "prefix", {
|
|
get: function() {
|
|
return "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "localName", {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "id", {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "className", {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "classList", {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
Object.defineProperty(XMLElement2.prototype, "attributes", {
|
|
get: function() {
|
|
if (!this.attributeMap || !this.attributeMap.nodes)
|
|
this.attributeMap = new XMLNamedNodeMap(this.attribs);
|
|
return this.attributeMap;
|
|
}
|
|
});
|
|
XMLElement2.prototype.clone = function() {
|
|
var att, attName, clonedSelf, ref1;
|
|
clonedSelf = Object.create(this);
|
|
if (clonedSelf.isRoot)
|
|
clonedSelf.documentObject = null;
|
|
clonedSelf.attribs = {};
|
|
ref1 = this.attribs;
|
|
for (attName in ref1) {
|
|
if (!hasProp.call(ref1, attName))
|
|
continue;
|
|
att = ref1[attName];
|
|
clonedSelf.attribs[attName] = att.clone();
|
|
}
|
|
clonedSelf.children = [];
|
|
this.children.forEach(function(child) {
|
|
var clonedChild;
|
|
clonedChild = child.clone();
|
|
clonedChild.parent = clonedSelf;
|
|
return clonedSelf.children.push(clonedChild);
|
|
});
|
|
return clonedSelf;
|
|
};
|
|
XMLElement2.prototype.attribute = function(name, value) {
|
|
var attName, attValue;
|
|
if (name != null)
|
|
name = getValue(name);
|
|
if (isObject(name))
|
|
for (attName in name) {
|
|
if (!hasProp.call(name, attName))
|
|
continue;
|
|
attValue = name[attName];
|
|
this.attribute(attName, attValue);
|
|
}
|
|
else {
|
|
if (isFunction(value))
|
|
value = value.apply();
|
|
if (this.options.keepNullAttributes && value == null)
|
|
this.attribs[name] = new XMLAttribute(this, name, "");
|
|
else if (value != null)
|
|
this.attribs[name] = new XMLAttribute(this, name, value);
|
|
}
|
|
return this;
|
|
};
|
|
XMLElement2.prototype.removeAttribute = function(name) {
|
|
var attName, j, len;
|
|
if (name == null)
|
|
throw new Error("Missing attribute name. " + this.debugInfo());
|
|
name = getValue(name);
|
|
if (Array.isArray(name))
|
|
for (j = 0, len = name.length;j < len; j++) {
|
|
attName = name[j];
|
|
delete this.attribs[attName];
|
|
}
|
|
else
|
|
delete this.attribs[name];
|
|
return this;
|
|
};
|
|
XMLElement2.prototype.toString = function(options) {
|
|
return this.options.writer.element(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLElement2.prototype.att = function(name, value) {
|
|
return this.attribute(name, value);
|
|
};
|
|
XMLElement2.prototype.a = function(name, value) {
|
|
return this.attribute(name, value);
|
|
};
|
|
XMLElement2.prototype.getAttribute = function(name) {
|
|
if (this.attribs.hasOwnProperty(name))
|
|
return this.attribs[name].value;
|
|
else
|
|
return null;
|
|
};
|
|
XMLElement2.prototype.setAttribute = function(name, value) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getAttributeNode = function(name) {
|
|
if (this.attribs.hasOwnProperty(name))
|
|
return this.attribs[name];
|
|
else
|
|
return null;
|
|
};
|
|
XMLElement2.prototype.setAttributeNode = function(newAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.removeAttributeNode = function(oldAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getElementsByTagName = function(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getAttributeNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.removeAttributeNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getAttributeNodeNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.setAttributeNodeNS = function(newAttr) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.hasAttribute = function(name) {
|
|
return this.attribs.hasOwnProperty(name);
|
|
};
|
|
XMLElement2.prototype.hasAttributeNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.setIdAttribute = function(name, isId) {
|
|
if (this.attribs.hasOwnProperty(name))
|
|
return this.attribs[name].isId;
|
|
else
|
|
return isId;
|
|
};
|
|
XMLElement2.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.setIdAttributeNode = function(idAttr, isId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getElementsByTagName = function(tagname) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.getElementsByClassName = function(classNames) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLElement2.prototype.isEqualNode = function(node) {
|
|
var i, j, ref1;
|
|
if (!XMLElement2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node))
|
|
return false;
|
|
if (node.namespaceURI !== this.namespaceURI)
|
|
return false;
|
|
if (node.prefix !== this.prefix)
|
|
return false;
|
|
if (node.localName !== this.localName)
|
|
return false;
|
|
if (node.attribs.length !== this.attribs.length)
|
|
return false;
|
|
for (i = j = 0, ref1 = this.attribs.length - 1;0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j)
|
|
if (!this.attribs[i].isEqualNode(node.attribs[i]))
|
|
return false;
|
|
return true;
|
|
};
|
|
return XMLElement2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLCharacterData.js
|
|
var require_XMLCharacterData = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLCharacterData, 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 = require_XMLNode();
|
|
module.exports = XMLCharacterData = function(superClass) {
|
|
extend(XMLCharacterData2, superClass);
|
|
function XMLCharacterData2(parent) {
|
|
XMLCharacterData2.__super__.constructor.call(this, parent);
|
|
this.value = "";
|
|
}
|
|
Object.defineProperty(XMLCharacterData2.prototype, "data", {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || "";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLCharacterData2.prototype, "length", {
|
|
get: function() {
|
|
return this.value.length;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLCharacterData2.prototype, "textContent", {
|
|
get: function() {
|
|
return this.value;
|
|
},
|
|
set: function(value) {
|
|
return this.value = value || "";
|
|
}
|
|
});
|
|
XMLCharacterData2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLCharacterData2.prototype.substringData = function(offset, count) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLCharacterData2.prototype.appendData = function(arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLCharacterData2.prototype.insertData = function(offset, arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLCharacterData2.prototype.deleteData = function(offset, count) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLCharacterData2.prototype.replaceData = function(offset, count, arg) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLCharacterData2.prototype.isEqualNode = function(node) {
|
|
if (!XMLCharacterData2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node))
|
|
return false;
|
|
if (node.data !== this.data)
|
|
return false;
|
|
return true;
|
|
};
|
|
return XMLCharacterData2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLCData.js
|
|
var require_XMLCData = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLCData, XMLCharacterData, 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;
|
|
NodeType = require_NodeType();
|
|
XMLCharacterData = require_XMLCharacterData();
|
|
module.exports = XMLCData = function(superClass) {
|
|
extend(XMLCData2, superClass);
|
|
function XMLCData2(parent, text) {
|
|
XMLCData2.__super__.constructor.call(this, parent);
|
|
if (text == null)
|
|
throw new Error("Missing CDATA text. " + this.debugInfo());
|
|
this.name = "#cdata-section";
|
|
this.type = NodeType.CData;
|
|
this.value = this.stringify.cdata(text);
|
|
}
|
|
XMLCData2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLCData2.prototype.toString = function(options) {
|
|
return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLCData2;
|
|
}(XMLCharacterData);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLComment.js
|
|
var require_XMLComment = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLComment, 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;
|
|
NodeType = require_NodeType();
|
|
XMLCharacterData = require_XMLCharacterData();
|
|
module.exports = XMLComment = function(superClass) {
|
|
extend(XMLComment2, superClass);
|
|
function XMLComment2(parent, text) {
|
|
XMLComment2.__super__.constructor.call(this, parent);
|
|
if (text == null)
|
|
throw new Error("Missing comment text. " + this.debugInfo());
|
|
this.name = "#comment";
|
|
this.type = NodeType.Comment;
|
|
this.value = this.stringify.comment(text);
|
|
}
|
|
XMLComment2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLComment2.prototype.toString = function(options) {
|
|
return this.options.writer.comment(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLComment2;
|
|
}(XMLCharacterData);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDeclaration.js
|
|
var require_XMLDeclaration = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDeclaration, XMLNode, isObject, 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;
|
|
isObject = require_Utility().isObject;
|
|
XMLNode = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDeclaration = function(superClass) {
|
|
extend(XMLDeclaration2, superClass);
|
|
function XMLDeclaration2(parent, version3, encoding, standalone) {
|
|
var ref;
|
|
XMLDeclaration2.__super__.constructor.call(this, parent);
|
|
if (isObject(version3))
|
|
ref = version3, version3 = ref.version, encoding = ref.encoding, standalone = ref.standalone;
|
|
if (!version3)
|
|
version3 = "1.0";
|
|
this.type = NodeType.Declaration;
|
|
this.version = this.stringify.xmlVersion(version3);
|
|
if (encoding != null)
|
|
this.encoding = this.stringify.xmlEncoding(encoding);
|
|
if (standalone != null)
|
|
this.standalone = this.stringify.xmlStandalone(standalone);
|
|
}
|
|
XMLDeclaration2.prototype.toString = function(options) {
|
|
return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLDeclaration2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDTDAttList.js
|
|
var require_XMLDTDAttList = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDTDAttList, 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 = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDTDAttList = function(superClass) {
|
|
extend(XMLDTDAttList2, superClass);
|
|
function XMLDTDAttList2(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
XMLDTDAttList2.__super__.constructor.call(this, parent);
|
|
if (elementName == null)
|
|
throw new Error("Missing DTD element name. " + this.debugInfo());
|
|
if (attributeName == null)
|
|
throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
|
|
if (!attributeType)
|
|
throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
|
|
if (!defaultValueType)
|
|
throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
|
|
if (defaultValueType.indexOf("#") !== 0)
|
|
defaultValueType = "#" + defaultValueType;
|
|
if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/))
|
|
throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
|
|
if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/))
|
|
throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
|
|
this.elementName = this.stringify.name(elementName);
|
|
this.type = NodeType.AttributeDeclaration;
|
|
this.attributeName = this.stringify.name(attributeName);
|
|
this.attributeType = this.stringify.dtdAttType(attributeType);
|
|
if (defaultValue)
|
|
this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
|
|
this.defaultValueType = defaultValueType;
|
|
}
|
|
XMLDTDAttList2.prototype.toString = function(options) {
|
|
return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLDTDAttList2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDTDEntity.js
|
|
var require_XMLDTDEntity = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDTDEntity, XMLNode, isObject, 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;
|
|
isObject = require_Utility().isObject;
|
|
XMLNode = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDTDEntity = function(superClass) {
|
|
extend(XMLDTDEntity2, superClass);
|
|
function XMLDTDEntity2(parent, pe, name, value) {
|
|
XMLDTDEntity2.__super__.constructor.call(this, parent);
|
|
if (name == null)
|
|
throw new Error("Missing DTD entity name. " + this.debugInfo(name));
|
|
if (value == null)
|
|
throw new Error("Missing DTD entity value. " + this.debugInfo(name));
|
|
this.pe = !!pe;
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.EntityDeclaration;
|
|
if (!isObject(value)) {
|
|
this.value = this.stringify.dtdEntityValue(value);
|
|
this.internal = true;
|
|
} else {
|
|
if (!value.pubID && !value.sysID)
|
|
throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
|
|
if (value.pubID && !value.sysID)
|
|
throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
|
|
this.internal = false;
|
|
if (value.pubID != null)
|
|
this.pubID = this.stringify.dtdPubID(value.pubID);
|
|
if (value.sysID != null)
|
|
this.sysID = this.stringify.dtdSysID(value.sysID);
|
|
if (value.nData != null)
|
|
this.nData = this.stringify.dtdNData(value.nData);
|
|
if (this.pe && this.nData)
|
|
throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
|
|
}
|
|
}
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "publicId", {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "systemId", {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "notationName", {
|
|
get: function() {
|
|
return this.nData || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "inputEncoding", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "xmlEncoding", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDEntity2.prototype, "xmlVersion", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
XMLDTDEntity2.prototype.toString = function(options) {
|
|
return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLDTDEntity2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDTDElement.js
|
|
var require_XMLDTDElement = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDTDElement, 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 = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDTDElement = function(superClass) {
|
|
extend(XMLDTDElement2, superClass);
|
|
function XMLDTDElement2(parent, name, value) {
|
|
XMLDTDElement2.__super__.constructor.call(this, parent);
|
|
if (name == null)
|
|
throw new Error("Missing DTD element name. " + this.debugInfo());
|
|
if (!value)
|
|
value = "(#PCDATA)";
|
|
if (Array.isArray(value))
|
|
value = "(" + value.join(",") + ")";
|
|
this.name = this.stringify.name(name);
|
|
this.type = NodeType.ElementDeclaration;
|
|
this.value = this.stringify.dtdElementValue(value);
|
|
}
|
|
XMLDTDElement2.prototype.toString = function(options) {
|
|
return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLDTDElement2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDTDNotation.js
|
|
var require_XMLDTDNotation = __commonJS((exports, module) => {
|
|
(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 = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDTDNotation = function(superClass) {
|
|
extend(XMLDTDNotation2, superClass);
|
|
function XMLDTDNotation2(parent, name, value) {
|
|
XMLDTDNotation2.__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(XMLDTDNotation2.prototype, "publicId", {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDTDNotation2.prototype, "systemId", {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
XMLDTDNotation2.prototype.toString = function(options) {
|
|
return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLDTDNotation2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDocType.js
|
|
var require_XMLDocType = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject, 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;
|
|
isObject = require_Utility().isObject;
|
|
XMLNode = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
XMLDTDAttList = require_XMLDTDAttList();
|
|
XMLDTDEntity = require_XMLDTDEntity();
|
|
XMLDTDElement = require_XMLDTDElement();
|
|
XMLDTDNotation = require_XMLDTDNotation();
|
|
XMLNamedNodeMap = require_XMLNamedNodeMap();
|
|
module.exports = XMLDocType = function(superClass) {
|
|
extend(XMLDocType2, superClass);
|
|
function XMLDocType2(parent, pubID, sysID) {
|
|
var child, i, len, ref, ref1, ref2;
|
|
XMLDocType2.__super__.constructor.call(this, parent);
|
|
this.type = NodeType.DocType;
|
|
if (parent.children) {
|
|
ref = parent.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.Element) {
|
|
this.name = child.name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.documentObject = parent;
|
|
if (isObject(pubID))
|
|
ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;
|
|
if (sysID == null)
|
|
ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];
|
|
if (pubID != null)
|
|
this.pubID = this.stringify.dtdPubID(pubID);
|
|
if (sysID != null)
|
|
this.sysID = this.stringify.dtdSysID(sysID);
|
|
}
|
|
Object.defineProperty(XMLDocType2.prototype, "entities", {
|
|
get: function() {
|
|
var child, i, len, nodes, ref;
|
|
nodes = {};
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.EntityDeclaration && !child.pe)
|
|
nodes[child.name] = child;
|
|
}
|
|
return new XMLNamedNodeMap(nodes);
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocType2.prototype, "notations", {
|
|
get: function() {
|
|
var child, i, len, nodes, ref;
|
|
nodes = {};
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.NotationDeclaration)
|
|
nodes[child.name] = child;
|
|
}
|
|
return new XMLNamedNodeMap(nodes);
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocType2.prototype, "publicId", {
|
|
get: function() {
|
|
return this.pubID;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocType2.prototype, "systemId", {
|
|
get: function() {
|
|
return this.sysID;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocType2.prototype, "internalSubset", {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
XMLDocType2.prototype.element = function(name, value) {
|
|
var child;
|
|
child = new XMLDTDElement(this, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLDocType2.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
var child;
|
|
child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLDocType2.prototype.entity = function(name, value) {
|
|
var child;
|
|
child = new XMLDTDEntity(this, false, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLDocType2.prototype.pEntity = function(name, value) {
|
|
var child;
|
|
child = new XMLDTDEntity(this, true, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLDocType2.prototype.notation = function(name, value) {
|
|
var child;
|
|
child = new XMLDTDNotation(this, name, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLDocType2.prototype.toString = function(options) {
|
|
return this.options.writer.docType(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLDocType2.prototype.ele = function(name, value) {
|
|
return this.element(name, value);
|
|
};
|
|
XMLDocType2.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
};
|
|
XMLDocType2.prototype.ent = function(name, value) {
|
|
return this.entity(name, value);
|
|
};
|
|
XMLDocType2.prototype.pent = function(name, value) {
|
|
return this.pEntity(name, value);
|
|
};
|
|
XMLDocType2.prototype.not = function(name, value) {
|
|
return this.notation(name, value);
|
|
};
|
|
XMLDocType2.prototype.up = function() {
|
|
return this.root() || this.documentObject;
|
|
};
|
|
XMLDocType2.prototype.isEqualNode = function(node) {
|
|
if (!XMLDocType2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node))
|
|
return false;
|
|
if (node.name !== this.name)
|
|
return false;
|
|
if (node.publicId !== this.publicId)
|
|
return false;
|
|
if (node.systemId !== this.systemId)
|
|
return false;
|
|
return true;
|
|
};
|
|
return XMLDocType2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLRaw.js
|
|
var require_XMLRaw = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLNode, XMLRaw, 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;
|
|
NodeType = require_NodeType();
|
|
XMLNode = require_XMLNode();
|
|
module.exports = XMLRaw = function(superClass) {
|
|
extend(XMLRaw2, superClass);
|
|
function XMLRaw2(parent, text) {
|
|
XMLRaw2.__super__.constructor.call(this, parent);
|
|
if (text == null)
|
|
throw new Error("Missing raw text. " + this.debugInfo());
|
|
this.type = NodeType.Raw;
|
|
this.value = this.stringify.raw(text);
|
|
}
|
|
XMLRaw2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLRaw2.prototype.toString = function(options) {
|
|
return this.options.writer.raw(this, this.options.writer.filterOptions(options));
|
|
};
|
|
return XMLRaw2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLText.js
|
|
var require_XMLText = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLText, 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;
|
|
NodeType = require_NodeType();
|
|
XMLCharacterData = require_XMLCharacterData();
|
|
module.exports = XMLText = function(superClass) {
|
|
extend(XMLText2, superClass);
|
|
function XMLText2(parent, text) {
|
|
XMLText2.__super__.constructor.call(this, parent);
|
|
if (text == null)
|
|
throw new Error("Missing element text. " + this.debugInfo());
|
|
this.name = "#text";
|
|
this.type = NodeType.Text;
|
|
this.value = this.stringify.text(text);
|
|
}
|
|
Object.defineProperty(XMLText2.prototype, "isElementContentWhitespace", {
|
|
get: function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
}
|
|
});
|
|
Object.defineProperty(XMLText2.prototype, "wholeText", {
|
|
get: function() {
|
|
var next, prev, str;
|
|
str = "";
|
|
prev = this.previousSibling;
|
|
while (prev) {
|
|
str = prev.data + str;
|
|
prev = prev.previousSibling;
|
|
}
|
|
str += this.data;
|
|
next = this.nextSibling;
|
|
while (next) {
|
|
str = str + next.data;
|
|
next = next.nextSibling;
|
|
}
|
|
return str;
|
|
}
|
|
});
|
|
XMLText2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLText2.prototype.toString = function(options) {
|
|
return this.options.writer.text(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLText2.prototype.splitText = function(offset) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLText2.prototype.replaceWholeText = function(content) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
return XMLText2;
|
|
}(XMLCharacterData);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
|
|
var require_XMLProcessingInstruction = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLCharacterData, XMLProcessingInstruction, 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;
|
|
NodeType = require_NodeType();
|
|
XMLCharacterData = require_XMLCharacterData();
|
|
module.exports = XMLProcessingInstruction = function(superClass) {
|
|
extend(XMLProcessingInstruction2, superClass);
|
|
function XMLProcessingInstruction2(parent, target, value) {
|
|
XMLProcessingInstruction2.__super__.constructor.call(this, parent);
|
|
if (target == null)
|
|
throw new Error("Missing instruction target. " + this.debugInfo());
|
|
this.type = NodeType.ProcessingInstruction;
|
|
this.target = this.stringify.insTarget(target);
|
|
this.name = this.target;
|
|
if (value)
|
|
this.value = this.stringify.insValue(value);
|
|
}
|
|
XMLProcessingInstruction2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLProcessingInstruction2.prototype.toString = function(options) {
|
|
return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLProcessingInstruction2.prototype.isEqualNode = function(node) {
|
|
if (!XMLProcessingInstruction2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node))
|
|
return false;
|
|
if (node.target !== this.target)
|
|
return false;
|
|
return true;
|
|
};
|
|
return XMLProcessingInstruction2;
|
|
}(XMLCharacterData);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDummy.js
|
|
var require_XMLDummy = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDummy, 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 = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
module.exports = XMLDummy = function(superClass) {
|
|
extend(XMLDummy2, superClass);
|
|
function XMLDummy2(parent) {
|
|
XMLDummy2.__super__.constructor.call(this, parent);
|
|
this.type = NodeType.Dummy;
|
|
}
|
|
XMLDummy2.prototype.clone = function() {
|
|
return Object.create(this);
|
|
};
|
|
XMLDummy2.prototype.toString = function(options) {
|
|
return "";
|
|
};
|
|
return XMLDummy2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLNodeList.js
|
|
var require_XMLNodeList = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLNodeList;
|
|
module.exports = XMLNodeList = function() {
|
|
function XMLNodeList2(nodes) {
|
|
this.nodes = nodes;
|
|
}
|
|
Object.defineProperty(XMLNodeList2.prototype, "length", {
|
|
get: function() {
|
|
return this.nodes.length || 0;
|
|
}
|
|
});
|
|
XMLNodeList2.prototype.clone = function() {
|
|
return this.nodes = null;
|
|
};
|
|
XMLNodeList2.prototype.item = function(index) {
|
|
return this.nodes[index] || null;
|
|
};
|
|
return XMLNodeList2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/DocumentPosition.js
|
|
var require_DocumentPosition = __commonJS((exports, module) => {
|
|
(function() {
|
|
module.exports = {
|
|
Disconnected: 1,
|
|
Preceding: 2,
|
|
Following: 4,
|
|
Contains: 8,
|
|
ContainedBy: 16,
|
|
ImplementationSpecific: 32
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLNode.js
|
|
var require_XMLNode = __commonJS((exports, module) => {
|
|
(function() {
|
|
var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1, hasProp = {}.hasOwnProperty;
|
|
ref1 = require_Utility(), 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 XMLNode2(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 = require_XMLElement();
|
|
XMLCData = require_XMLCData();
|
|
XMLComment = require_XMLComment();
|
|
XMLDeclaration = require_XMLDeclaration();
|
|
XMLDocType = require_XMLDocType();
|
|
XMLRaw = require_XMLRaw();
|
|
XMLText = require_XMLText();
|
|
XMLProcessingInstruction = require_XMLProcessingInstruction();
|
|
XMLDummy = require_XMLDummy();
|
|
NodeType = require_NodeType();
|
|
XMLNodeList = require_XMLNodeList();
|
|
XMLNamedNodeMap = require_XMLNamedNodeMap();
|
|
DocumentPosition = require_DocumentPosition();
|
|
}
|
|
}
|
|
Object.defineProperty(XMLNode2.prototype, "nodeName", {
|
|
get: function() {
|
|
return this.name;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "nodeType", {
|
|
get: function() {
|
|
return this.type;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "nodeValue", {
|
|
get: function() {
|
|
return this.value;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "parentNode", {
|
|
get: function() {
|
|
return this.parent;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "childNodes", {
|
|
get: function() {
|
|
if (!this.childNodeList || !this.childNodeList.nodes)
|
|
this.childNodeList = new XMLNodeList(this.children);
|
|
return this.childNodeList;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "firstChild", {
|
|
get: function() {
|
|
return this.children[0] || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "lastChild", {
|
|
get: function() {
|
|
return this.children[this.children.length - 1] || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "previousSibling", {
|
|
get: function() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
return this.parent.children[i - 1] || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "nextSibling", {
|
|
get: function() {
|
|
var i;
|
|
i = this.parent.children.indexOf(this);
|
|
return this.parent.children[i + 1] || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.prototype, "ownerDocument", {
|
|
get: function() {
|
|
return this.document() || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLNode2.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());
|
|
}
|
|
});
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.insertBefore = function(name, attributes, text) {
|
|
var child, i, newChild, refChild, removed;
|
|
if (name != null ? name.type : undefined) {
|
|
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;
|
|
}
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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 = []));
|
|
return this.parent;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.text = function(value) {
|
|
var child;
|
|
if (isObject(value))
|
|
this.element(value);
|
|
child = new XMLText(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLNode2.prototype.cdata = function(value) {
|
|
var child;
|
|
child = new XMLCData(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLNode2.prototype.comment = function(value) {
|
|
var child;
|
|
child = new XMLComment(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.raw = function(value) {
|
|
var child;
|
|
child = new XMLRaw(this, value);
|
|
this.children.push(child);
|
|
return this;
|
|
};
|
|
XMLNode2.prototype.dummy = function() {
|
|
var child;
|
|
child = new XMLDummy(this);
|
|
return child;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.declaration = function(version3, encoding, standalone) {
|
|
var doc, xmldec;
|
|
doc = this.document();
|
|
xmldec = new XMLDeclaration(doc, version3, 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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.document = function() {
|
|
var node;
|
|
node = this;
|
|
while (node)
|
|
if (node.type === NodeType.Document)
|
|
return node;
|
|
else
|
|
node = node.parent;
|
|
};
|
|
XMLNode2.prototype.end = function(options) {
|
|
return this.document().end(options);
|
|
};
|
|
XMLNode2.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];
|
|
};
|
|
XMLNode2.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];
|
|
};
|
|
XMLNode2.prototype.importDocument = function(doc) {
|
|
var clonedRoot;
|
|
clonedRoot = doc.root().clone();
|
|
clonedRoot.parent = this;
|
|
clonedRoot.isRoot = false;
|
|
this.children.push(clonedRoot);
|
|
return this;
|
|
};
|
|
XMLNode2.prototype.debugInfo = function(name) {
|
|
var ref2, ref3;
|
|
name = name || this.name;
|
|
if (name == null && !((ref2 = this.parent) != null ? ref2.name : undefined))
|
|
return "";
|
|
else if (name == null)
|
|
return "parent: <" + this.parent.name + ">";
|
|
else if (!((ref3 = this.parent) != null ? ref3.name : undefined))
|
|
return "node: <" + name + ">";
|
|
else
|
|
return "node: <" + name + ">, parent: <" + this.parent.name + ">";
|
|
};
|
|
XMLNode2.prototype.ele = function(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
};
|
|
XMLNode2.prototype.nod = function(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
};
|
|
XMLNode2.prototype.txt = function(value) {
|
|
return this.text(value);
|
|
};
|
|
XMLNode2.prototype.dat = function(value) {
|
|
return this.cdata(value);
|
|
};
|
|
XMLNode2.prototype.com = function(value) {
|
|
return this.comment(value);
|
|
};
|
|
XMLNode2.prototype.ins = function(target, value) {
|
|
return this.instruction(target, value);
|
|
};
|
|
XMLNode2.prototype.doc = function() {
|
|
return this.document();
|
|
};
|
|
XMLNode2.prototype.dec = function(version3, encoding, standalone) {
|
|
return this.declaration(version3, encoding, standalone);
|
|
};
|
|
XMLNode2.prototype.e = function(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
};
|
|
XMLNode2.prototype.n = function(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
};
|
|
XMLNode2.prototype.t = function(value) {
|
|
return this.text(value);
|
|
};
|
|
XMLNode2.prototype.d = function(value) {
|
|
return this.cdata(value);
|
|
};
|
|
XMLNode2.prototype.c = function(value) {
|
|
return this.comment(value);
|
|
};
|
|
XMLNode2.prototype.r = function(value) {
|
|
return this.raw(value);
|
|
};
|
|
XMLNode2.prototype.i = function(target, value) {
|
|
return this.instruction(target, value);
|
|
};
|
|
XMLNode2.prototype.u = function() {
|
|
return this.up();
|
|
};
|
|
XMLNode2.prototype.importXMLBuilder = function(doc) {
|
|
return this.importDocument(doc);
|
|
};
|
|
XMLNode2.prototype.replaceChild = function(newChild, oldChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.removeChild = function(oldChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.appendChild = function(newChild) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.hasChildNodes = function() {
|
|
return this.children.length !== 0;
|
|
};
|
|
XMLNode2.prototype.cloneNode = function(deep) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.normalize = function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.isSupported = function(feature, version3) {
|
|
return true;
|
|
};
|
|
XMLNode2.prototype.hasAttributes = function() {
|
|
return this.attribs.length !== 0;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.isSameNode = function(other) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.lookupPrefix = function(namespaceURI) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.isDefaultNamespace = function(namespaceURI) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.lookupNamespaceURI = function(prefix) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.getFeature = function(feature, version3) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.setUserData = function(key, data, handler) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.getUserData = function(key) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLNode2.prototype.contains = function(other) {
|
|
if (!other)
|
|
return false;
|
|
return other === this || this.isDescendant(other);
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.prototype.isAncestor = function(node) {
|
|
return node.isDescendant(this);
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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;
|
|
};
|
|
XMLNode2.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 XMLNode2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLStringifier.js
|
|
var require_XMLStringifier = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLStringifier, bind = function(fn, me) {
|
|
return function() {
|
|
return fn.apply(me, arguments);
|
|
};
|
|
}, hasProp = {}.hasOwnProperty;
|
|
module.exports = XMLStringifier = function() {
|
|
function XMLStringifier2(options) {
|
|
this.assertLegalName = bind(this.assertLegalName, this);
|
|
this.assertLegalChar = bind(this.assertLegalChar, this);
|
|
var key, ref, value;
|
|
options || (options = {});
|
|
this.options = options;
|
|
if (!this.options.version)
|
|
this.options.version = "1.0";
|
|
ref = options.stringify || {};
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key))
|
|
continue;
|
|
value = ref[key];
|
|
this[key] = value;
|
|
}
|
|
}
|
|
XMLStringifier2.prototype.name = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalName("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.text = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar(this.textEscape("" + val || ""));
|
|
};
|
|
XMLStringifier2.prototype.cdata = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
val = "" + val || "";
|
|
val = val.replace("]]>", "]]]]><![CDATA[>");
|
|
return this.assertLegalChar(val);
|
|
};
|
|
XMLStringifier2.prototype.comment = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
val = "" + val || "";
|
|
if (val.match(/--/))
|
|
throw new Error("Comment text cannot contain double-hypen: " + val);
|
|
return this.assertLegalChar(val);
|
|
};
|
|
XMLStringifier2.prototype.raw = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return "" + val || "";
|
|
};
|
|
XMLStringifier2.prototype.attValue = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar(this.attEscape(val = "" + val || ""));
|
|
};
|
|
XMLStringifier2.prototype.insTarget = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.insValue = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
val = "" + val || "";
|
|
if (val.match(/\?>/))
|
|
throw new Error("Invalid processing instruction value: " + val);
|
|
return this.assertLegalChar(val);
|
|
};
|
|
XMLStringifier2.prototype.xmlVersion = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
val = "" + val || "";
|
|
if (!val.match(/1\.[0-9]+/))
|
|
throw new Error("Invalid version number: " + val);
|
|
return val;
|
|
};
|
|
XMLStringifier2.prototype.xmlEncoding = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
val = "" + val || "";
|
|
if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/))
|
|
throw new Error("Invalid encoding: " + val);
|
|
return this.assertLegalChar(val);
|
|
};
|
|
XMLStringifier2.prototype.xmlStandalone = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
if (val)
|
|
return "yes";
|
|
else
|
|
return "no";
|
|
};
|
|
XMLStringifier2.prototype.dtdPubID = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdSysID = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdElementValue = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdAttType = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdAttDefault = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdEntityValue = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.dtdNData = function(val) {
|
|
if (this.options.noValidation)
|
|
return val;
|
|
return this.assertLegalChar("" + val || "");
|
|
};
|
|
XMLStringifier2.prototype.convertAttKey = "@";
|
|
XMLStringifier2.prototype.convertPIKey = "?";
|
|
XMLStringifier2.prototype.convertTextKey = "#text";
|
|
XMLStringifier2.prototype.convertCDataKey = "#cdata";
|
|
XMLStringifier2.prototype.convertCommentKey = "#comment";
|
|
XMLStringifier2.prototype.convertRawKey = "#raw";
|
|
XMLStringifier2.prototype.assertLegalChar = function(str) {
|
|
var regex3, res;
|
|
if (this.options.noValidation)
|
|
return str;
|
|
regex3 = "";
|
|
if (this.options.version === "1.0") {
|
|
regex3 = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
|
|
if (res = str.match(regex3))
|
|
throw new Error("Invalid character in string: " + str + " at index " + res.index);
|
|
} else if (this.options.version === "1.1") {
|
|
regex3 = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
|
|
if (res = str.match(regex3))
|
|
throw new Error("Invalid character in string: " + str + " at index " + res.index);
|
|
}
|
|
return str;
|
|
};
|
|
XMLStringifier2.prototype.assertLegalName = function(str) {
|
|
var regex3;
|
|
if (this.options.noValidation)
|
|
return str;
|
|
this.assertLegalChar(str);
|
|
regex3 = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
|
|
if (!str.match(regex3))
|
|
throw new Error("Invalid character in name");
|
|
return str;
|
|
};
|
|
XMLStringifier2.prototype.textEscape = function(str) {
|
|
var ampregex;
|
|
if (this.options.noValidation)
|
|
return str;
|
|
ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
|
|
return str.replace(ampregex, "&").replace(/</g, "<").replace(/>/g, ">").replace(/\r/g, "
");
|
|
};
|
|
XMLStringifier2.prototype.attEscape = function(str) {
|
|
var ampregex;
|
|
if (this.options.noValidation)
|
|
return str;
|
|
ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
|
|
return str.replace(ampregex, "&").replace(/</g, "<").replace(/"/g, """).replace(/\t/g, "	").replace(/\n/g, "
").replace(/\r/g, "
");
|
|
};
|
|
return XMLStringifier2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/WriterState.js
|
|
var require_WriterState = __commonJS((exports, module) => {
|
|
(function() {
|
|
module.exports = {
|
|
None: 0,
|
|
OpenTag: 1,
|
|
InsideTag: 2,
|
|
CloseTag: 3
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLWriterBase.js
|
|
var require_XMLWriterBase = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign, hasProp = {}.hasOwnProperty;
|
|
assign = require_Utility().assign;
|
|
NodeType = require_NodeType();
|
|
XMLDeclaration = require_XMLDeclaration();
|
|
XMLDocType = require_XMLDocType();
|
|
XMLCData = require_XMLCData();
|
|
XMLComment = require_XMLComment();
|
|
XMLElement = require_XMLElement();
|
|
XMLRaw = require_XMLRaw();
|
|
XMLText = require_XMLText();
|
|
XMLProcessingInstruction = require_XMLProcessingInstruction();
|
|
XMLDummy = require_XMLDummy();
|
|
XMLDTDAttList = require_XMLDTDAttList();
|
|
XMLDTDElement = require_XMLDTDElement();
|
|
XMLDTDEntity = require_XMLDTDEntity();
|
|
XMLDTDNotation = require_XMLDTDNotation();
|
|
WriterState = require_WriterState();
|
|
module.exports = XMLWriterBase = function() {
|
|
function XMLWriterBase2(options) {
|
|
var key, ref, value;
|
|
options || (options = {});
|
|
this.options = options;
|
|
ref = options.writer || {};
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key))
|
|
continue;
|
|
value = ref[key];
|
|
this["_" + key] = this[key];
|
|
this[key] = value;
|
|
}
|
|
}
|
|
XMLWriterBase2.prototype.filterOptions = function(options) {
|
|
var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6;
|
|
options || (options = {});
|
|
options = assign({}, this.options, options);
|
|
filteredOptions = {
|
|
writer: this
|
|
};
|
|
filteredOptions.pretty = options.pretty || false;
|
|
filteredOptions.allowEmpty = options.allowEmpty || false;
|
|
filteredOptions.indent = (ref = options.indent) != null ? ref : " ";
|
|
filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : "\n";
|
|
filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
|
|
filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0;
|
|
filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : "";
|
|
if (filteredOptions.spaceBeforeSlash === true)
|
|
filteredOptions.spaceBeforeSlash = " ";
|
|
filteredOptions.suppressPrettyCount = 0;
|
|
filteredOptions.user = {};
|
|
filteredOptions.state = WriterState.None;
|
|
return filteredOptions;
|
|
};
|
|
XMLWriterBase2.prototype.indent = function(node, options, level) {
|
|
var indentLevel;
|
|
if (!options.pretty || options.suppressPrettyCount)
|
|
return "";
|
|
else if (options.pretty) {
|
|
indentLevel = (level || 0) + options.offset + 1;
|
|
if (indentLevel > 0)
|
|
return new Array(indentLevel).join(options.indent);
|
|
}
|
|
return "";
|
|
};
|
|
XMLWriterBase2.prototype.endline = function(node, options, level) {
|
|
if (!options.pretty || options.suppressPrettyCount)
|
|
return "";
|
|
else
|
|
return options.newline;
|
|
};
|
|
XMLWriterBase2.prototype.attribute = function(att, options, level) {
|
|
var r;
|
|
this.openAttribute(att, options, level);
|
|
r = " " + att.name + '="' + att.value + '"';
|
|
this.closeAttribute(att, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.cdata = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<![CDATA[";
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += "]]>" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.comment = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<!-- ";
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += " -->" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.declaration = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<?xml";
|
|
options.state = WriterState.InsideTag;
|
|
r += ' version="' + node.version + '"';
|
|
if (node.encoding != null)
|
|
r += ' encoding="' + node.encoding + '"';
|
|
if (node.standalone != null)
|
|
r += ' standalone="' + node.standalone + '"';
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + "?>";
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.docType = function(node, options, level) {
|
|
var child, i, len, r, ref;
|
|
level || (level = 0);
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
r += "<!DOCTYPE " + node.root().name;
|
|
if (node.pubID && node.sysID)
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
else if (node.sysID)
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
if (node.children.length > 0) {
|
|
r += " [";
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
ref = node.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
r += this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += "]";
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + ">";
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.element = function(node, options, level) {
|
|
var att, child, childNodeCount, firstChildNode, i, j, len, len1, name, prettySuppressed, r, ref, ref1, ref2;
|
|
level || (level = 0);
|
|
prettySuppressed = false;
|
|
r = "";
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r += this.indent(node, options, level) + "<" + node.name;
|
|
ref = node.attribs;
|
|
for (name in ref) {
|
|
if (!hasProp.call(ref, name))
|
|
continue;
|
|
att = ref[name];
|
|
r += this.attribute(att, options, level);
|
|
}
|
|
childNodeCount = node.children.length;
|
|
firstChildNode = childNodeCount === 0 ? null : node.children[0];
|
|
if (childNodeCount === 0 || node.children.every(function(e) {
|
|
return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === "";
|
|
}))
|
|
if (options.allowEmpty) {
|
|
r += ">";
|
|
options.state = WriterState.CloseTag;
|
|
r += "</" + node.name + ">" + this.endline(node, options, level);
|
|
} else {
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + "/>" + this.endline(node, options, level);
|
|
}
|
|
else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && firstChildNode.value != null) {
|
|
r += ">";
|
|
options.state = WriterState.InsideTag;
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
r += this.writeChildNode(firstChildNode, options, level + 1);
|
|
options.suppressPrettyCount--;
|
|
prettySuppressed = false;
|
|
options.state = WriterState.CloseTag;
|
|
r += "</" + node.name + ">" + this.endline(node, options, level);
|
|
} else {
|
|
if (options.dontPrettyTextNodes) {
|
|
ref1 = node.children;
|
|
for (i = 0, len = ref1.length;i < len; i++) {
|
|
child = ref1[i];
|
|
if ((child.type === NodeType.Text || child.type === NodeType.Raw) && child.value != null) {
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
r += ">" + this.endline(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
ref2 = node.children;
|
|
for (j = 0, len1 = ref2.length;j < len1; j++) {
|
|
child = ref2[j];
|
|
r += this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += this.indent(node, options, level) + "</" + node.name + ">";
|
|
if (prettySuppressed)
|
|
options.suppressPrettyCount--;
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
}
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.writeChildNode = function(node, options, level) {
|
|
switch (node.type) {
|
|
case NodeType.CData:
|
|
return this.cdata(node, options, level);
|
|
case NodeType.Comment:
|
|
return this.comment(node, options, level);
|
|
case NodeType.Element:
|
|
return this.element(node, options, level);
|
|
case NodeType.Raw:
|
|
return this.raw(node, options, level);
|
|
case NodeType.Text:
|
|
return this.text(node, options, level);
|
|
case NodeType.ProcessingInstruction:
|
|
return this.processingInstruction(node, options, level);
|
|
case NodeType.Dummy:
|
|
return "";
|
|
case NodeType.Declaration:
|
|
return this.declaration(node, options, level);
|
|
case NodeType.DocType:
|
|
return this.docType(node, options, level);
|
|
case NodeType.AttributeDeclaration:
|
|
return this.dtdAttList(node, options, level);
|
|
case NodeType.ElementDeclaration:
|
|
return this.dtdElement(node, options, level);
|
|
case NodeType.EntityDeclaration:
|
|
return this.dtdEntity(node, options, level);
|
|
case NodeType.NotationDeclaration:
|
|
return this.dtdNotation(node, options, level);
|
|
default:
|
|
throw new Error("Unknown XML node type: " + node.constructor.name);
|
|
}
|
|
};
|
|
XMLWriterBase2.prototype.processingInstruction = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<?";
|
|
options.state = WriterState.InsideTag;
|
|
r += node.target;
|
|
if (node.value)
|
|
r += " " + node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + "?>";
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.raw = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.text = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level);
|
|
options.state = WriterState.InsideTag;
|
|
r += node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.dtdAttList = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<!ATTLIST";
|
|
options.state = WriterState.InsideTag;
|
|
r += " " + node.elementName + " " + node.attributeName + " " + node.attributeType;
|
|
if (node.defaultValueType !== "#DEFAULT")
|
|
r += " " + node.defaultValueType;
|
|
if (node.defaultValue)
|
|
r += ' "' + node.defaultValue + '"';
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.dtdElement = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<!ELEMENT";
|
|
options.state = WriterState.InsideTag;
|
|
r += " " + node.name + " " + node.value;
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.dtdEntity = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<!ENTITY";
|
|
options.state = WriterState.InsideTag;
|
|
if (node.pe)
|
|
r += " %";
|
|
r += " " + node.name;
|
|
if (node.value)
|
|
r += ' "' + node.value + '"';
|
|
else {
|
|
if (node.pubID && node.sysID)
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
else if (node.sysID)
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
if (node.nData)
|
|
r += " NDATA " + node.nData;
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.dtdNotation = function(node, options, level) {
|
|
var r;
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
r = this.indent(node, options, level) + "<!NOTATION";
|
|
options.state = WriterState.InsideTag;
|
|
r += " " + node.name;
|
|
if (node.pubID && node.sysID)
|
|
r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
else if (node.pubID)
|
|
r += ' PUBLIC "' + node.pubID + '"';
|
|
else if (node.sysID)
|
|
r += ' SYSTEM "' + node.sysID + '"';
|
|
options.state = WriterState.CloseTag;
|
|
r += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
|
|
options.state = WriterState.None;
|
|
this.closeNode(node, options, level);
|
|
return r;
|
|
};
|
|
XMLWriterBase2.prototype.openNode = function(node, options, level) {
|
|
};
|
|
XMLWriterBase2.prototype.closeNode = function(node, options, level) {
|
|
};
|
|
XMLWriterBase2.prototype.openAttribute = function(att, options, level) {
|
|
};
|
|
XMLWriterBase2.prototype.closeAttribute = function(att, options, level) {
|
|
};
|
|
return XMLWriterBase2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLStringWriter.js
|
|
var require_XMLStringWriter = __commonJS((exports, module) => {
|
|
(function() {
|
|
var XMLStringWriter, XMLWriterBase, 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;
|
|
XMLWriterBase = require_XMLWriterBase();
|
|
module.exports = XMLStringWriter = function(superClass) {
|
|
extend(XMLStringWriter2, superClass);
|
|
function XMLStringWriter2(options) {
|
|
XMLStringWriter2.__super__.constructor.call(this, options);
|
|
}
|
|
XMLStringWriter2.prototype.document = function(doc, options) {
|
|
var child, i, len, r, ref;
|
|
options = this.filterOptions(options);
|
|
r = "";
|
|
ref = doc.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
r += this.writeChildNode(child, options, 0);
|
|
}
|
|
if (options.pretty && r.slice(-options.newline.length) === options.newline)
|
|
r = r.slice(0, -options.newline.length);
|
|
return r;
|
|
};
|
|
return XMLStringWriter2;
|
|
}(XMLWriterBase);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDocument.js
|
|
var require_XMLDocument = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject, 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;
|
|
isPlainObject = require_Utility().isPlainObject;
|
|
XMLDOMImplementation = require_XMLDOMImplementation();
|
|
XMLDOMConfiguration = require_XMLDOMConfiguration();
|
|
XMLNode = require_XMLNode();
|
|
NodeType = require_NodeType();
|
|
XMLStringifier = require_XMLStringifier();
|
|
XMLStringWriter = require_XMLStringWriter();
|
|
module.exports = XMLDocument = function(superClass) {
|
|
extend(XMLDocument2, superClass);
|
|
function XMLDocument2(options) {
|
|
XMLDocument2.__super__.constructor.call(this, null);
|
|
this.name = "#document";
|
|
this.type = NodeType.Document;
|
|
this.documentURI = null;
|
|
this.domConfig = new XMLDOMConfiguration;
|
|
options || (options = {});
|
|
if (!options.writer)
|
|
options.writer = new XMLStringWriter;
|
|
this.options = options;
|
|
this.stringify = new XMLStringifier(options);
|
|
}
|
|
Object.defineProperty(XMLDocument2.prototype, "implementation", {
|
|
value: new XMLDOMImplementation
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "doctype", {
|
|
get: function() {
|
|
var child, i, len, ref;
|
|
ref = this.children;
|
|
for (i = 0, len = ref.length;i < len; i++) {
|
|
child = ref[i];
|
|
if (child.type === NodeType.DocType)
|
|
return child;
|
|
}
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "documentElement", {
|
|
get: function() {
|
|
return this.rootObject || null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "inputEncoding", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "strictErrorChecking", {
|
|
get: function() {
|
|
return false;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "xmlEncoding", {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration)
|
|
return this.children[0].encoding;
|
|
else
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "xmlStandalone", {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration)
|
|
return this.children[0].standalone === "yes";
|
|
else
|
|
return false;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "xmlVersion", {
|
|
get: function() {
|
|
if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration)
|
|
return this.children[0].version;
|
|
else
|
|
return "1.0";
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "URL", {
|
|
get: function() {
|
|
return this.documentURI;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "origin", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "compatMode", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "characterSet", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
Object.defineProperty(XMLDocument2.prototype, "contentType", {
|
|
get: function() {
|
|
return null;
|
|
}
|
|
});
|
|
XMLDocument2.prototype.end = function(writer) {
|
|
var writerOptions;
|
|
writerOptions = {};
|
|
if (!writer)
|
|
writer = this.options.writer;
|
|
else if (isPlainObject(writer)) {
|
|
writerOptions = writer;
|
|
writer = this.options.writer;
|
|
}
|
|
return writer.document(this, writer.filterOptions(writerOptions));
|
|
};
|
|
XMLDocument2.prototype.toString = function(options) {
|
|
return this.options.writer.document(this, this.options.writer.filterOptions(options));
|
|
};
|
|
XMLDocument2.prototype.createElement = function(tagName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createDocumentFragment = function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createTextNode = function(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createComment = function(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createCDATASection = function(data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createProcessingInstruction = function(target, data) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createAttribute = function(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createEntityReference = function(name) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.getElementsByTagName = function(tagname) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.importNode = function(importedNode, deep) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createElementNS = function(namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createAttributeNS = function(namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.getElementById = function(elementId) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.adoptNode = function(source) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.normalizeDocument = function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.renameNode = function(node, namespaceURI, qualifiedName) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.getElementsByClassName = function(classNames) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createEvent = function(eventInterface) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createRange = function() {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createNodeIterator = function(root, whatToShow, filter) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
XMLDocument2.prototype.createTreeWalker = function(root, whatToShow, filter) {
|
|
throw new Error("This DOM method is not implemented." + this.debugInfo());
|
|
};
|
|
return XMLDocument2;
|
|
}(XMLNode);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLDocumentCB.js
|
|
var require_XMLDocumentCB = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref, hasProp = {}.hasOwnProperty;
|
|
ref = require_Utility(), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;
|
|
NodeType = require_NodeType();
|
|
XMLDocument = require_XMLDocument();
|
|
XMLElement = require_XMLElement();
|
|
XMLCData = require_XMLCData();
|
|
XMLComment = require_XMLComment();
|
|
XMLRaw = require_XMLRaw();
|
|
XMLText = require_XMLText();
|
|
XMLProcessingInstruction = require_XMLProcessingInstruction();
|
|
XMLDeclaration = require_XMLDeclaration();
|
|
XMLDocType = require_XMLDocType();
|
|
XMLDTDAttList = require_XMLDTDAttList();
|
|
XMLDTDEntity = require_XMLDTDEntity();
|
|
XMLDTDElement = require_XMLDTDElement();
|
|
XMLDTDNotation = require_XMLDTDNotation();
|
|
XMLAttribute = require_XMLAttribute();
|
|
XMLStringifier = require_XMLStringifier();
|
|
XMLStringWriter = require_XMLStringWriter();
|
|
WriterState = require_WriterState();
|
|
module.exports = XMLDocumentCB = function() {
|
|
function XMLDocumentCB2(options, onData, onEnd) {
|
|
var writerOptions;
|
|
this.name = "?xml";
|
|
this.type = NodeType.Document;
|
|
options || (options = {});
|
|
writerOptions = {};
|
|
if (!options.writer)
|
|
options.writer = new XMLStringWriter;
|
|
else if (isPlainObject(options.writer)) {
|
|
writerOptions = options.writer;
|
|
options.writer = new XMLStringWriter;
|
|
}
|
|
this.options = options;
|
|
this.writer = options.writer;
|
|
this.writerOptions = this.writer.filterOptions(writerOptions);
|
|
this.stringify = new XMLStringifier(options);
|
|
this.onDataCallback = onData || function() {
|
|
};
|
|
this.onEndCallback = onEnd || function() {
|
|
};
|
|
this.currentNode = null;
|
|
this.currentLevel = -1;
|
|
this.openTags = {};
|
|
this.documentStarted = false;
|
|
this.documentCompleted = false;
|
|
this.root = null;
|
|
}
|
|
XMLDocumentCB2.prototype.createChildNode = function(node) {
|
|
var att, attName, attributes, child, i, len, ref1, ref2;
|
|
switch (node.type) {
|
|
case NodeType.CData:
|
|
this.cdata(node.value);
|
|
break;
|
|
case NodeType.Comment:
|
|
this.comment(node.value);
|
|
break;
|
|
case NodeType.Element:
|
|
attributes = {};
|
|
ref1 = node.attribs;
|
|
for (attName in ref1) {
|
|
if (!hasProp.call(ref1, attName))
|
|
continue;
|
|
att = ref1[attName];
|
|
attributes[attName] = att.value;
|
|
}
|
|
this.node(node.name, attributes);
|
|
break;
|
|
case NodeType.Dummy:
|
|
this.dummy();
|
|
break;
|
|
case NodeType.Raw:
|
|
this.raw(node.value);
|
|
break;
|
|
case NodeType.Text:
|
|
this.text(node.value);
|
|
break;
|
|
case NodeType.ProcessingInstruction:
|
|
this.instruction(node.target, node.value);
|
|
break;
|
|
default:
|
|
throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
|
|
}
|
|
ref2 = node.children;
|
|
for (i = 0, len = ref2.length;i < len; i++) {
|
|
child = ref2[i];
|
|
this.createChildNode(child);
|
|
if (child.type === NodeType.Element)
|
|
this.up();
|
|
}
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.dummy = function() {
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.node = function(name, attributes, text) {
|
|
var ref1;
|
|
if (name == null)
|
|
throw new Error("Missing node name.");
|
|
if (this.root && this.currentLevel === -1)
|
|
throw new Error("Document can only have one root node. " + this.debugInfo(name));
|
|
this.openCurrent();
|
|
name = getValue(name);
|
|
if (attributes == null)
|
|
attributes = {};
|
|
attributes = getValue(attributes);
|
|
if (!isObject(attributes))
|
|
ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
|
|
this.currentNode = new XMLElement(this, name, attributes);
|
|
this.currentNode.children = false;
|
|
this.currentLevel++;
|
|
this.openTags[this.currentLevel] = this.currentNode;
|
|
if (text != null)
|
|
this.text(text);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.element = function(name, attributes, text) {
|
|
var child, i, len, oldValidationFlag, ref1, root;
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType)
|
|
this.dtdElement.apply(this, arguments);
|
|
else if (Array.isArray(name) || isObject(name) || isFunction(name)) {
|
|
oldValidationFlag = this.options.noValidation;
|
|
this.options.noValidation = true;
|
|
root = new XMLDocument(this.options).element("TEMP_ROOT");
|
|
root.element(name);
|
|
this.options.noValidation = oldValidationFlag;
|
|
ref1 = root.children;
|
|
for (i = 0, len = ref1.length;i < len; i++) {
|
|
child = ref1[i];
|
|
this.createChildNode(child);
|
|
if (child.type === NodeType.Element)
|
|
this.up();
|
|
}
|
|
} else
|
|
this.node(name, attributes, text);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.attribute = function(name, value) {
|
|
var attName, attValue;
|
|
if (!this.currentNode || this.currentNode.children)
|
|
throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
|
|
if (name != null)
|
|
name = getValue(name);
|
|
if (isObject(name))
|
|
for (attName in name) {
|
|
if (!hasProp.call(name, attName))
|
|
continue;
|
|
attValue = name[attName];
|
|
this.attribute(attName, attValue);
|
|
}
|
|
else {
|
|
if (isFunction(value))
|
|
value = value.apply();
|
|
if (this.options.keepNullAttributes && value == null)
|
|
this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
|
|
else if (value != null)
|
|
this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
|
|
}
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.text = function(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLText(this, value);
|
|
this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.cdata = function(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLCData(this, value);
|
|
this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.comment = function(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLComment(this, value);
|
|
this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.raw = function(value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLRaw(this, value);
|
|
this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.instruction = function(target, value) {
|
|
var i, insTarget, insValue, len, node;
|
|
this.openCurrent();
|
|
if (target != null)
|
|
target = getValue(target);
|
|
if (value != null)
|
|
value = getValue(value);
|
|
if (Array.isArray(target))
|
|
for (i = 0, len = target.length;i < len; i++) {
|
|
insTarget = target[i];
|
|
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();
|
|
node = new XMLProcessingInstruction(this, target, value);
|
|
this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
}
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.declaration = function(version3, encoding, standalone) {
|
|
var node;
|
|
this.openCurrent();
|
|
if (this.documentStarted)
|
|
throw new Error("declaration() must be the first node.");
|
|
node = new XMLDeclaration(this, version3, encoding, standalone);
|
|
this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.doctype = function(root, pubID, sysID) {
|
|
this.openCurrent();
|
|
if (root == null)
|
|
throw new Error("Missing root node name.");
|
|
if (this.root)
|
|
throw new Error("dtd() must come before the root node.");
|
|
this.currentNode = new XMLDocType(this, pubID, sysID);
|
|
this.currentNode.rootNodeName = root;
|
|
this.currentNode.children = false;
|
|
this.currentLevel++;
|
|
this.openTags[this.currentLevel] = this.currentNode;
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.dtdElement = function(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDElement(this, name, value);
|
|
this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
|
|
this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.entity = function(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDEntity(this, false, name, value);
|
|
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.pEntity = function(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDEntity(this, true, name, value);
|
|
this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.notation = function(name, value) {
|
|
var node;
|
|
this.openCurrent();
|
|
node = new XMLDTDNotation(this, name, value);
|
|
this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.up = function() {
|
|
if (this.currentLevel < 0)
|
|
throw new Error("The document node has no parent.");
|
|
if (this.currentNode) {
|
|
if (this.currentNode.children)
|
|
this.closeNode(this.currentNode);
|
|
else
|
|
this.openNode(this.currentNode);
|
|
this.currentNode = null;
|
|
} else
|
|
this.closeNode(this.openTags[this.currentLevel]);
|
|
delete this.openTags[this.currentLevel];
|
|
this.currentLevel--;
|
|
return this;
|
|
};
|
|
XMLDocumentCB2.prototype.end = function() {
|
|
while (this.currentLevel >= 0)
|
|
this.up();
|
|
return this.onEnd();
|
|
};
|
|
XMLDocumentCB2.prototype.openCurrent = function() {
|
|
if (this.currentNode) {
|
|
this.currentNode.children = true;
|
|
return this.openNode(this.currentNode);
|
|
}
|
|
};
|
|
XMLDocumentCB2.prototype.openNode = function(node) {
|
|
var att, chunk, name, ref1;
|
|
if (!node.isOpen) {
|
|
if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element)
|
|
this.root = node;
|
|
chunk = "";
|
|
if (node.type === NodeType.Element) {
|
|
this.writerOptions.state = WriterState.OpenTag;
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<" + node.name;
|
|
ref1 = node.attribs;
|
|
for (name in ref1) {
|
|
if (!hasProp.call(ref1, name))
|
|
continue;
|
|
att = ref1[name];
|
|
chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
|
|
}
|
|
chunk += (node.children ? ">" : "/>") + this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
this.writerOptions.state = WriterState.InsideTag;
|
|
} else {
|
|
this.writerOptions.state = WriterState.OpenTag;
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<!DOCTYPE " + node.rootNodeName;
|
|
if (node.pubID && node.sysID)
|
|
chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
|
|
else if (node.sysID)
|
|
chunk += ' SYSTEM "' + node.sysID + '"';
|
|
if (node.children) {
|
|
chunk += " [";
|
|
this.writerOptions.state = WriterState.InsideTag;
|
|
} else {
|
|
this.writerOptions.state = WriterState.CloseTag;
|
|
chunk += ">";
|
|
}
|
|
chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
}
|
|
this.onData(chunk, this.currentLevel);
|
|
return node.isOpen = true;
|
|
}
|
|
};
|
|
XMLDocumentCB2.prototype.closeNode = function(node) {
|
|
var chunk;
|
|
if (!node.isClosed) {
|
|
chunk = "";
|
|
this.writerOptions.state = WriterState.CloseTag;
|
|
if (node.type === NodeType.Element)
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "</" + node.name + ">" + this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
else
|
|
chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "]>" + this.writer.endline(node, this.writerOptions, this.currentLevel);
|
|
this.writerOptions.state = WriterState.None;
|
|
this.onData(chunk, this.currentLevel);
|
|
return node.isClosed = true;
|
|
}
|
|
};
|
|
XMLDocumentCB2.prototype.onData = function(chunk, level) {
|
|
this.documentStarted = true;
|
|
return this.onDataCallback(chunk, level + 1);
|
|
};
|
|
XMLDocumentCB2.prototype.onEnd = function() {
|
|
this.documentCompleted = true;
|
|
return this.onEndCallback();
|
|
};
|
|
XMLDocumentCB2.prototype.debugInfo = function(name) {
|
|
if (name == null)
|
|
return "";
|
|
else
|
|
return "node: <" + name + ">";
|
|
};
|
|
XMLDocumentCB2.prototype.ele = function() {
|
|
return this.element.apply(this, arguments);
|
|
};
|
|
XMLDocumentCB2.prototype.nod = function(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
};
|
|
XMLDocumentCB2.prototype.txt = function(value) {
|
|
return this.text(value);
|
|
};
|
|
XMLDocumentCB2.prototype.dat = function(value) {
|
|
return this.cdata(value);
|
|
};
|
|
XMLDocumentCB2.prototype.com = function(value) {
|
|
return this.comment(value);
|
|
};
|
|
XMLDocumentCB2.prototype.ins = function(target, value) {
|
|
return this.instruction(target, value);
|
|
};
|
|
XMLDocumentCB2.prototype.dec = function(version3, encoding, standalone) {
|
|
return this.declaration(version3, encoding, standalone);
|
|
};
|
|
XMLDocumentCB2.prototype.dtd = function(root, pubID, sysID) {
|
|
return this.doctype(root, pubID, sysID);
|
|
};
|
|
XMLDocumentCB2.prototype.e = function(name, attributes, text) {
|
|
return this.element(name, attributes, text);
|
|
};
|
|
XMLDocumentCB2.prototype.n = function(name, attributes, text) {
|
|
return this.node(name, attributes, text);
|
|
};
|
|
XMLDocumentCB2.prototype.t = function(value) {
|
|
return this.text(value);
|
|
};
|
|
XMLDocumentCB2.prototype.d = function(value) {
|
|
return this.cdata(value);
|
|
};
|
|
XMLDocumentCB2.prototype.c = function(value) {
|
|
return this.comment(value);
|
|
};
|
|
XMLDocumentCB2.prototype.r = function(value) {
|
|
return this.raw(value);
|
|
};
|
|
XMLDocumentCB2.prototype.i = function(target, value) {
|
|
return this.instruction(target, value);
|
|
};
|
|
XMLDocumentCB2.prototype.att = function() {
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType)
|
|
return this.attList.apply(this, arguments);
|
|
else
|
|
return this.attribute.apply(this, arguments);
|
|
};
|
|
XMLDocumentCB2.prototype.a = function() {
|
|
if (this.currentNode && this.currentNode.type === NodeType.DocType)
|
|
return this.attList.apply(this, arguments);
|
|
else
|
|
return this.attribute.apply(this, arguments);
|
|
};
|
|
XMLDocumentCB2.prototype.ent = function(name, value) {
|
|
return this.entity(name, value);
|
|
};
|
|
XMLDocumentCB2.prototype.pent = function(name, value) {
|
|
return this.pEntity(name, value);
|
|
};
|
|
XMLDocumentCB2.prototype.not = function(name, value) {
|
|
return this.notation(name, value);
|
|
};
|
|
return XMLDocumentCB2;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/XMLStreamWriter.js
|
|
var require_XMLStreamWriter = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, WriterState, XMLStreamWriter, XMLWriterBase, 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;
|
|
NodeType = require_NodeType();
|
|
XMLWriterBase = require_XMLWriterBase();
|
|
WriterState = require_WriterState();
|
|
module.exports = XMLStreamWriter = function(superClass) {
|
|
extend(XMLStreamWriter2, superClass);
|
|
function XMLStreamWriter2(stream, options) {
|
|
this.stream = stream;
|
|
XMLStreamWriter2.__super__.constructor.call(this, options);
|
|
}
|
|
XMLStreamWriter2.prototype.endline = function(node, options, level) {
|
|
if (node.isLastRootNode && options.state === WriterState.CloseTag)
|
|
return "";
|
|
else
|
|
return XMLStreamWriter2.__super__.endline.call(this, node, options, level);
|
|
};
|
|
XMLStreamWriter2.prototype.document = function(doc, options) {
|
|
var child, i, j, k, len, len1, ref, ref1, results;
|
|
ref = doc.children;
|
|
for (i = j = 0, len = ref.length;j < len; i = ++j) {
|
|
child = ref[i];
|
|
child.isLastRootNode = i === doc.children.length - 1;
|
|
}
|
|
options = this.filterOptions(options);
|
|
ref1 = doc.children;
|
|
results = [];
|
|
for (k = 0, len1 = ref1.length;k < len1; k++) {
|
|
child = ref1[k];
|
|
results.push(this.writeChildNode(child, options, 0));
|
|
}
|
|
return results;
|
|
};
|
|
XMLStreamWriter2.prototype.attribute = function(att, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.attribute.call(this, att, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.cdata = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.cdata.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.comment = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.comment.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.declaration = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.declaration.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.docType = function(node, options, level) {
|
|
var child, j, len, ref;
|
|
level || (level = 0);
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
this.stream.write(this.indent(node, options, level));
|
|
this.stream.write("<!DOCTYPE " + node.root().name);
|
|
if (node.pubID && node.sysID)
|
|
this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
|
|
else if (node.sysID)
|
|
this.stream.write(' SYSTEM "' + node.sysID + '"');
|
|
if (node.children.length > 0) {
|
|
this.stream.write(" [");
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.InsideTag;
|
|
ref = node.children;
|
|
for (j = 0, len = ref.length;j < len; j++) {
|
|
child = ref[j];
|
|
this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write("]");
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(options.spaceBeforeSlash + ">");
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.None;
|
|
return this.closeNode(node, options, level);
|
|
};
|
|
XMLStreamWriter2.prototype.element = function(node, options, level) {
|
|
var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1;
|
|
level || (level = 0);
|
|
this.openNode(node, options, level);
|
|
options.state = WriterState.OpenTag;
|
|
this.stream.write(this.indent(node, options, level) + "<" + node.name);
|
|
ref = node.attribs;
|
|
for (name in ref) {
|
|
if (!hasProp.call(ref, name))
|
|
continue;
|
|
att = ref[name];
|
|
this.attribute(att, options, level);
|
|
}
|
|
childNodeCount = node.children.length;
|
|
firstChildNode = childNodeCount === 0 ? null : node.children[0];
|
|
if (childNodeCount === 0 || node.children.every(function(e) {
|
|
return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === "";
|
|
}))
|
|
if (options.allowEmpty) {
|
|
this.stream.write(">");
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write("</" + node.name + ">");
|
|
} else {
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(options.spaceBeforeSlash + "/>");
|
|
}
|
|
else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && firstChildNode.value != null) {
|
|
this.stream.write(">");
|
|
options.state = WriterState.InsideTag;
|
|
options.suppressPrettyCount++;
|
|
prettySuppressed = true;
|
|
this.writeChildNode(firstChildNode, options, level + 1);
|
|
options.suppressPrettyCount--;
|
|
prettySuppressed = false;
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write("</" + node.name + ">");
|
|
} else {
|
|
this.stream.write(">" + this.endline(node, options, level));
|
|
options.state = WriterState.InsideTag;
|
|
ref1 = node.children;
|
|
for (j = 0, len = ref1.length;j < len; j++) {
|
|
child = ref1[j];
|
|
this.writeChildNode(child, options, level + 1);
|
|
}
|
|
options.state = WriterState.CloseTag;
|
|
this.stream.write(this.indent(node, options, level) + "</" + node.name + ">");
|
|
}
|
|
this.stream.write(this.endline(node, options, level));
|
|
options.state = WriterState.None;
|
|
return this.closeNode(node, options, level);
|
|
};
|
|
XMLStreamWriter2.prototype.processingInstruction = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.processingInstruction.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.raw = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.raw.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.text = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.text.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.dtdAttList = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.dtdAttList.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.dtdElement = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.dtdElement.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.dtdEntity = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.dtdEntity.call(this, node, options, level));
|
|
};
|
|
XMLStreamWriter2.prototype.dtdNotation = function(node, options, level) {
|
|
return this.stream.write(XMLStreamWriter2.__super__.dtdNotation.call(this, node, options, level));
|
|
};
|
|
return XMLStreamWriter2;
|
|
}(XMLWriterBase);
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xmlbuilder/lib/index.js
|
|
var require_lib2 = __commonJS((exports, module) => {
|
|
(function() {
|
|
var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
|
|
ref = require_Utility(), assign = ref.assign, isFunction = ref.isFunction;
|
|
XMLDOMImplementation = require_XMLDOMImplementation();
|
|
XMLDocument = require_XMLDocument();
|
|
XMLDocumentCB = require_XMLDocumentCB();
|
|
XMLStringWriter = require_XMLStringWriter();
|
|
XMLStreamWriter = require_XMLStreamWriter();
|
|
NodeType = require_NodeType();
|
|
WriterState = require_WriterState();
|
|
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;
|
|
};
|
|
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);
|
|
};
|
|
exports.stringWriter = function(options) {
|
|
return new XMLStringWriter(options);
|
|
};
|
|
exports.streamWriter = function(stream, options) {
|
|
return new XMLStreamWriter(stream, options);
|
|
};
|
|
exports.implementation = new XMLDOMImplementation;
|
|
exports.nodeType = NodeType;
|
|
exports.writerState = WriterState;
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xml2js/lib/builder.js
|
|
var require_builder = __commonJS((exports) => {
|
|
(function() {
|
|
var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA, hasProp = {}.hasOwnProperty;
|
|
builder = require_lib2();
|
|
defaults = require_defaults().defaults;
|
|
requiresCDATA = function(entry) {
|
|
return typeof entry === "string" && (entry.indexOf("&") >= 0 || entry.indexOf(">") >= 0 || entry.indexOf("<") >= 0);
|
|
};
|
|
wrapCDATA = function(entry) {
|
|
return "<![CDATA[" + escapeCDATA(entry) + "]]>";
|
|
};
|
|
escapeCDATA = function(entry) {
|
|
return entry.replace("]]>", "]]]]><![CDATA[>");
|
|
};
|
|
exports.Builder = function() {
|
|
function Builder(opts) {
|
|
var key, ref, value;
|
|
this.options = {};
|
|
ref = defaults["0.2"];
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key))
|
|
continue;
|
|
value = ref[key];
|
|
this.options[key] = value;
|
|
}
|
|
for (key in opts) {
|
|
if (!hasProp.call(opts, key))
|
|
continue;
|
|
value = opts[key];
|
|
this.options[key] = value;
|
|
}
|
|
}
|
|
Builder.prototype.buildObject = function(rootObj) {
|
|
var attrkey, charkey, render, rootElement, rootName;
|
|
attrkey = this.options.attrkey;
|
|
charkey = this.options.charkey;
|
|
if (Object.keys(rootObj).length === 1 && this.options.rootName === defaults["0.2"].rootName) {
|
|
rootName = Object.keys(rootObj)[0];
|
|
rootObj = rootObj[rootName];
|
|
} else
|
|
rootName = this.options.rootName;
|
|
render = function(_this) {
|
|
return function(element, obj) {
|
|
var attr, child, entry, index, key, value;
|
|
if (typeof obj !== "object")
|
|
if (_this.options.cdata && requiresCDATA(obj))
|
|
element.raw(wrapCDATA(obj));
|
|
else
|
|
element.txt(obj);
|
|
else if (Array.isArray(obj))
|
|
for (index in obj) {
|
|
if (!hasProp.call(obj, index))
|
|
continue;
|
|
child = obj[index];
|
|
for (key in child) {
|
|
entry = child[key];
|
|
element = render(element.ele(key), entry).up();
|
|
}
|
|
}
|
|
else
|
|
for (key in obj) {
|
|
if (!hasProp.call(obj, key))
|
|
continue;
|
|
child = obj[key];
|
|
if (key === attrkey) {
|
|
if (typeof child === "object")
|
|
for (attr in child) {
|
|
value = child[attr];
|
|
element = element.att(attr, value);
|
|
}
|
|
} else if (key === charkey)
|
|
if (_this.options.cdata && requiresCDATA(child))
|
|
element = element.raw(wrapCDATA(child));
|
|
else
|
|
element = element.txt(child);
|
|
else if (Array.isArray(child))
|
|
for (index in child) {
|
|
if (!hasProp.call(child, index))
|
|
continue;
|
|
entry = child[index];
|
|
if (typeof entry === "string")
|
|
if (_this.options.cdata && requiresCDATA(entry))
|
|
element = element.ele(key).raw(wrapCDATA(entry)).up();
|
|
else
|
|
element = element.ele(key, entry).up();
|
|
else
|
|
element = render(element.ele(key), entry).up();
|
|
}
|
|
else if (typeof child === "object")
|
|
element = render(element.ele(key), child).up();
|
|
else if (typeof child === "string" && _this.options.cdata && requiresCDATA(child))
|
|
element = element.ele(key).raw(wrapCDATA(child)).up();
|
|
else {
|
|
if (child == null)
|
|
child = "";
|
|
element = element.ele(key, child.toString()).up();
|
|
}
|
|
}
|
|
return element;
|
|
};
|
|
}(this);
|
|
rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
|
|
headless: this.options.headless,
|
|
allowSurrogateChars: this.options.allowSurrogateChars
|
|
});
|
|
return render(rootElement, rootObj).end(this.options.renderOpts);
|
|
};
|
|
return Builder;
|
|
}();
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/sax/lib/sax.js
|
|
var require_sax = __commonJS((exports) => {
|
|
(function(sax) {
|
|
sax.parser = function(strict, opt) {
|
|
return new SAXParser(strict, opt);
|
|
};
|
|
sax.SAXParser = SAXParser;
|
|
sax.SAXStream = SAXStream;
|
|
sax.createStream = createStream;
|
|
sax.MAX_BUFFER_LENGTH = 64 * 1024;
|
|
var buffers = [
|
|
"comment",
|
|
"sgmlDecl",
|
|
"textNode",
|
|
"tagName",
|
|
"doctype",
|
|
"procInstName",
|
|
"procInstBody",
|
|
"entity",
|
|
"attribName",
|
|
"attribValue",
|
|
"cdata",
|
|
"script"
|
|
];
|
|
sax.EVENTS = [
|
|
"text",
|
|
"processinginstruction",
|
|
"sgmldeclaration",
|
|
"doctype",
|
|
"comment",
|
|
"opentagstart",
|
|
"attribute",
|
|
"opentag",
|
|
"closetag",
|
|
"opencdata",
|
|
"cdata",
|
|
"closecdata",
|
|
"error",
|
|
"end",
|
|
"ready",
|
|
"script",
|
|
"opennamespace",
|
|
"closenamespace"
|
|
];
|
|
function SAXParser(strict, opt) {
|
|
if (!(this instanceof SAXParser))
|
|
return new SAXParser(strict, opt);
|
|
var parser = this;
|
|
clearBuffers(parser);
|
|
parser.q = parser.c = "";
|
|
parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
|
|
parser.opt = opt || {};
|
|
parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
|
|
parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
|
|
parser.tags = [];
|
|
parser.closed = parser.closedRoot = parser.sawRoot = false;
|
|
parser.tag = parser.error = null;
|
|
parser.strict = !!strict;
|
|
parser.noscript = !!(strict || parser.opt.noscript);
|
|
parser.state = S.BEGIN;
|
|
parser.strictEntities = parser.opt.strictEntities;
|
|
parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES);
|
|
parser.attribList = [];
|
|
if (parser.opt.xmlns)
|
|
parser.ns = Object.create(rootNS);
|
|
parser.trackPosition = parser.opt.position !== false;
|
|
if (parser.trackPosition)
|
|
parser.position = parser.line = parser.column = 0;
|
|
emit(parser, "onready");
|
|
}
|
|
if (!Object.create)
|
|
Object.create = function(o) {
|
|
function F() {
|
|
}
|
|
F.prototype = o;
|
|
var newf = new F;
|
|
return newf;
|
|
};
|
|
if (!Object.keys)
|
|
Object.keys = function(o) {
|
|
var a = [];
|
|
for (var i in o)
|
|
if (o.hasOwnProperty(i))
|
|
a.push(i);
|
|
return a;
|
|
};
|
|
function checkBufferLength(parser) {
|
|
var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10);
|
|
var maxActual = 0;
|
|
for (var i = 0, l = buffers.length;i < l; i++) {
|
|
var len = parser[buffers[i]].length;
|
|
if (len > maxAllowed)
|
|
switch (buffers[i]) {
|
|
case "textNode":
|
|
closeText(parser);
|
|
break;
|
|
case "cdata":
|
|
emitNode(parser, "oncdata", parser.cdata);
|
|
parser.cdata = "";
|
|
break;
|
|
case "script":
|
|
emitNode(parser, "onscript", parser.script);
|
|
parser.script = "";
|
|
break;
|
|
default:
|
|
error(parser, "Max buffer length exceeded: " + buffers[i]);
|
|
}
|
|
maxActual = Math.max(maxActual, len);
|
|
}
|
|
var m = sax.MAX_BUFFER_LENGTH - maxActual;
|
|
parser.bufferCheckPosition = m + parser.position;
|
|
}
|
|
function clearBuffers(parser) {
|
|
for (var i = 0, l = buffers.length;i < l; i++)
|
|
parser[buffers[i]] = "";
|
|
}
|
|
function flushBuffers(parser) {
|
|
closeText(parser);
|
|
if (parser.cdata !== "") {
|
|
emitNode(parser, "oncdata", parser.cdata);
|
|
parser.cdata = "";
|
|
}
|
|
if (parser.script !== "") {
|
|
emitNode(parser, "onscript", parser.script);
|
|
parser.script = "";
|
|
}
|
|
}
|
|
SAXParser.prototype = {
|
|
end: function() {
|
|
end(this);
|
|
},
|
|
write,
|
|
resume: function() {
|
|
this.error = null;
|
|
return this;
|
|
},
|
|
close: function() {
|
|
return this.write(null);
|
|
},
|
|
flush: function() {
|
|
flushBuffers(this);
|
|
}
|
|
};
|
|
var Stream;
|
|
try {
|
|
Stream = __require("stream").Stream;
|
|
} catch (ex) {
|
|
Stream = function() {
|
|
};
|
|
}
|
|
var streamWraps = sax.EVENTS.filter(function(ev) {
|
|
return ev !== "error" && ev !== "end";
|
|
});
|
|
function createStream(strict, opt) {
|
|
return new SAXStream(strict, opt);
|
|
}
|
|
function SAXStream(strict, opt) {
|
|
if (!(this instanceof SAXStream))
|
|
return new SAXStream(strict, opt);
|
|
Stream.apply(this);
|
|
this._parser = new SAXParser(strict, opt);
|
|
this.writable = true;
|
|
this.readable = true;
|
|
var me = this;
|
|
this._parser.onend = function() {
|
|
me.emit("end");
|
|
};
|
|
this._parser.onerror = function(er) {
|
|
me.emit("error", er);
|
|
me._parser.error = null;
|
|
};
|
|
this._decoder = null;
|
|
streamWraps.forEach(function(ev) {
|
|
Object.defineProperty(me, "on" + ev, {
|
|
get: function() {
|
|
return me._parser["on" + ev];
|
|
},
|
|
set: function(h) {
|
|
if (!h) {
|
|
me.removeAllListeners(ev);
|
|
me._parser["on" + ev] = h;
|
|
return h;
|
|
}
|
|
me.on(ev, h);
|
|
},
|
|
enumerable: true,
|
|
configurable: false
|
|
});
|
|
});
|
|
}
|
|
SAXStream.prototype = Object.create(Stream.prototype, {
|
|
constructor: {
|
|
value: SAXStream
|
|
}
|
|
});
|
|
SAXStream.prototype.write = function(data) {
|
|
if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
|
|
if (!this._decoder) {
|
|
var SD = __require("string_decoder").StringDecoder;
|
|
this._decoder = new SD("utf8");
|
|
}
|
|
data = this._decoder.write(data);
|
|
}
|
|
this._parser.write(data.toString());
|
|
this.emit("data", data);
|
|
return true;
|
|
};
|
|
SAXStream.prototype.end = function(chunk) {
|
|
if (chunk && chunk.length)
|
|
this.write(chunk);
|
|
this._parser.end();
|
|
return true;
|
|
};
|
|
SAXStream.prototype.on = function(ev, handler) {
|
|
var me = this;
|
|
if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1)
|
|
me._parser["on" + ev] = function() {
|
|
var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
|
|
args.splice(0, 0, ev);
|
|
me.emit.apply(me, args);
|
|
};
|
|
return Stream.prototype.on.call(me, ev, handler);
|
|
};
|
|
var CDATA = "[CDATA[";
|
|
var DOCTYPE = "DOCTYPE";
|
|
var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
|
|
var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
|
|
var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
|
|
var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
|
|
var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
|
|
var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
|
|
var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
|
|
function isWhitespace(c) {
|
|
return c === " " || c === "\n" || c === "\r" || c === "\t";
|
|
}
|
|
function isQuote(c) {
|
|
return c === '"' || c === "\'";
|
|
}
|
|
function isAttribEnd(c) {
|
|
return c === ">" || isWhitespace(c);
|
|
}
|
|
function isMatch(regex3, c) {
|
|
return regex3.test(c);
|
|
}
|
|
function notMatch(regex3, c) {
|
|
return !isMatch(regex3, c);
|
|
}
|
|
var S = 0;
|
|
sax.STATE = {
|
|
BEGIN: S++,
|
|
BEGIN_WHITESPACE: S++,
|
|
TEXT: S++,
|
|
TEXT_ENTITY: S++,
|
|
OPEN_WAKA: S++,
|
|
SGML_DECL: S++,
|
|
SGML_DECL_QUOTED: S++,
|
|
DOCTYPE: S++,
|
|
DOCTYPE_QUOTED: S++,
|
|
DOCTYPE_DTD: S++,
|
|
DOCTYPE_DTD_QUOTED: S++,
|
|
COMMENT_STARTING: S++,
|
|
COMMENT: S++,
|
|
COMMENT_ENDING: S++,
|
|
COMMENT_ENDED: S++,
|
|
CDATA: S++,
|
|
CDATA_ENDING: S++,
|
|
CDATA_ENDING_2: S++,
|
|
PROC_INST: S++,
|
|
PROC_INST_BODY: S++,
|
|
PROC_INST_ENDING: S++,
|
|
OPEN_TAG: S++,
|
|
OPEN_TAG_SLASH: S++,
|
|
ATTRIB: S++,
|
|
ATTRIB_NAME: S++,
|
|
ATTRIB_NAME_SAW_WHITE: S++,
|
|
ATTRIB_VALUE: S++,
|
|
ATTRIB_VALUE_QUOTED: S++,
|
|
ATTRIB_VALUE_CLOSED: S++,
|
|
ATTRIB_VALUE_UNQUOTED: S++,
|
|
ATTRIB_VALUE_ENTITY_Q: S++,
|
|
ATTRIB_VALUE_ENTITY_U: S++,
|
|
CLOSE_TAG: S++,
|
|
CLOSE_TAG_SAW_WHITE: S++,
|
|
SCRIPT: S++,
|
|
SCRIPT_ENDING: S++
|
|
};
|
|
sax.XML_ENTITIES = {
|
|
amp: "&",
|
|
gt: ">",
|
|
lt: "<",
|
|
quot: '"',
|
|
apos: "'"
|
|
};
|
|
sax.ENTITIES = {
|
|
amp: "&",
|
|
gt: ">",
|
|
lt: "<",
|
|
quot: '"',
|
|
apos: "'",
|
|
AElig: 198,
|
|
Aacute: 193,
|
|
Acirc: 194,
|
|
Agrave: 192,
|
|
Aring: 197,
|
|
Atilde: 195,
|
|
Auml: 196,
|
|
Ccedil: 199,
|
|
ETH: 208,
|
|
Eacute: 201,
|
|
Ecirc: 202,
|
|
Egrave: 200,
|
|
Euml: 203,
|
|
Iacute: 205,
|
|
Icirc: 206,
|
|
Igrave: 204,
|
|
Iuml: 207,
|
|
Ntilde: 209,
|
|
Oacute: 211,
|
|
Ocirc: 212,
|
|
Ograve: 210,
|
|
Oslash: 216,
|
|
Otilde: 213,
|
|
Ouml: 214,
|
|
THORN: 222,
|
|
Uacute: 218,
|
|
Ucirc: 219,
|
|
Ugrave: 217,
|
|
Uuml: 220,
|
|
Yacute: 221,
|
|
aacute: 225,
|
|
acirc: 226,
|
|
aelig: 230,
|
|
agrave: 224,
|
|
aring: 229,
|
|
atilde: 227,
|
|
auml: 228,
|
|
ccedil: 231,
|
|
eacute: 233,
|
|
ecirc: 234,
|
|
egrave: 232,
|
|
eth: 240,
|
|
euml: 235,
|
|
iacute: 237,
|
|
icirc: 238,
|
|
igrave: 236,
|
|
iuml: 239,
|
|
ntilde: 241,
|
|
oacute: 243,
|
|
ocirc: 244,
|
|
ograve: 242,
|
|
oslash: 248,
|
|
otilde: 245,
|
|
ouml: 246,
|
|
szlig: 223,
|
|
thorn: 254,
|
|
uacute: 250,
|
|
ucirc: 251,
|
|
ugrave: 249,
|
|
uuml: 252,
|
|
yacute: 253,
|
|
yuml: 255,
|
|
copy: 169,
|
|
reg: 174,
|
|
nbsp: 160,
|
|
iexcl: 161,
|
|
cent: 162,
|
|
pound: 163,
|
|
curren: 164,
|
|
yen: 165,
|
|
brvbar: 166,
|
|
sect: 167,
|
|
uml: 168,
|
|
ordf: 170,
|
|
laquo: 171,
|
|
not: 172,
|
|
shy: 173,
|
|
macr: 175,
|
|
deg: 176,
|
|
plusmn: 177,
|
|
sup1: 185,
|
|
sup2: 178,
|
|
sup3: 179,
|
|
acute: 180,
|
|
micro: 181,
|
|
para: 182,
|
|
middot: 183,
|
|
cedil: 184,
|
|
ordm: 186,
|
|
raquo: 187,
|
|
frac14: 188,
|
|
frac12: 189,
|
|
frac34: 190,
|
|
iquest: 191,
|
|
times: 215,
|
|
divide: 247,
|
|
OElig: 338,
|
|
oelig: 339,
|
|
Scaron: 352,
|
|
scaron: 353,
|
|
Yuml: 376,
|
|
fnof: 402,
|
|
circ: 710,
|
|
tilde: 732,
|
|
Alpha: 913,
|
|
Beta: 914,
|
|
Gamma: 915,
|
|
Delta: 916,
|
|
Epsilon: 917,
|
|
Zeta: 918,
|
|
Eta: 919,
|
|
Theta: 920,
|
|
Iota: 921,
|
|
Kappa: 922,
|
|
Lambda: 923,
|
|
Mu: 924,
|
|
Nu: 925,
|
|
Xi: 926,
|
|
Omicron: 927,
|
|
Pi: 928,
|
|
Rho: 929,
|
|
Sigma: 931,
|
|
Tau: 932,
|
|
Upsilon: 933,
|
|
Phi: 934,
|
|
Chi: 935,
|
|
Psi: 936,
|
|
Omega: 937,
|
|
alpha: 945,
|
|
beta: 946,
|
|
gamma: 947,
|
|
delta: 948,
|
|
epsilon: 949,
|
|
zeta: 950,
|
|
eta: 951,
|
|
theta: 952,
|
|
iota: 953,
|
|
kappa: 954,
|
|
lambda: 955,
|
|
mu: 956,
|
|
nu: 957,
|
|
xi: 958,
|
|
omicron: 959,
|
|
pi: 960,
|
|
rho: 961,
|
|
sigmaf: 962,
|
|
sigma: 963,
|
|
tau: 964,
|
|
upsilon: 965,
|
|
phi: 966,
|
|
chi: 967,
|
|
psi: 968,
|
|
omega: 969,
|
|
thetasym: 977,
|
|
upsih: 978,
|
|
piv: 982,
|
|
ensp: 8194,
|
|
emsp: 8195,
|
|
thinsp: 8201,
|
|
zwnj: 8204,
|
|
zwj: 8205,
|
|
lrm: 8206,
|
|
rlm: 8207,
|
|
ndash: 8211,
|
|
mdash: 8212,
|
|
lsquo: 8216,
|
|
rsquo: 8217,
|
|
sbquo: 8218,
|
|
ldquo: 8220,
|
|
rdquo: 8221,
|
|
bdquo: 8222,
|
|
dagger: 8224,
|
|
Dagger: 8225,
|
|
bull: 8226,
|
|
hellip: 8230,
|
|
permil: 8240,
|
|
prime: 8242,
|
|
Prime: 8243,
|
|
lsaquo: 8249,
|
|
rsaquo: 8250,
|
|
oline: 8254,
|
|
frasl: 8260,
|
|
euro: 8364,
|
|
image: 8465,
|
|
weierp: 8472,
|
|
real: 8476,
|
|
trade: 8482,
|
|
alefsym: 8501,
|
|
larr: 8592,
|
|
uarr: 8593,
|
|
rarr: 8594,
|
|
darr: 8595,
|
|
harr: 8596,
|
|
crarr: 8629,
|
|
lArr: 8656,
|
|
uArr: 8657,
|
|
rArr: 8658,
|
|
dArr: 8659,
|
|
hArr: 8660,
|
|
forall: 8704,
|
|
part: 8706,
|
|
exist: 8707,
|
|
empty: 8709,
|
|
nabla: 8711,
|
|
isin: 8712,
|
|
notin: 8713,
|
|
ni: 8715,
|
|
prod: 8719,
|
|
sum: 8721,
|
|
minus: 8722,
|
|
lowast: 8727,
|
|
radic: 8730,
|
|
prop: 8733,
|
|
infin: 8734,
|
|
ang: 8736,
|
|
and: 8743,
|
|
or: 8744,
|
|
cap: 8745,
|
|
cup: 8746,
|
|
int: 8747,
|
|
there4: 8756,
|
|
sim: 8764,
|
|
cong: 8773,
|
|
asymp: 8776,
|
|
ne: 8800,
|
|
equiv: 8801,
|
|
le: 8804,
|
|
ge: 8805,
|
|
sub: 8834,
|
|
sup: 8835,
|
|
nsub: 8836,
|
|
sube: 8838,
|
|
supe: 8839,
|
|
oplus: 8853,
|
|
otimes: 8855,
|
|
perp: 8869,
|
|
sdot: 8901,
|
|
lceil: 8968,
|
|
rceil: 8969,
|
|
lfloor: 8970,
|
|
rfloor: 8971,
|
|
lang: 9001,
|
|
rang: 9002,
|
|
loz: 9674,
|
|
spades: 9824,
|
|
clubs: 9827,
|
|
hearts: 9829,
|
|
diams: 9830
|
|
};
|
|
Object.keys(sax.ENTITIES).forEach(function(key) {
|
|
var e = sax.ENTITIES[key];
|
|
var s2 = typeof e === "number" ? String.fromCharCode(e) : e;
|
|
sax.ENTITIES[key] = s2;
|
|
});
|
|
for (var s in sax.STATE)
|
|
sax.STATE[sax.STATE[s]] = s;
|
|
S = sax.STATE;
|
|
function emit(parser, event, data) {
|
|
parser[event] && parser[event](data);
|
|
}
|
|
function emitNode(parser, nodeType, data) {
|
|
if (parser.textNode)
|
|
closeText(parser);
|
|
emit(parser, nodeType, data);
|
|
}
|
|
function closeText(parser) {
|
|
parser.textNode = textopts(parser.opt, parser.textNode);
|
|
if (parser.textNode)
|
|
emit(parser, "ontext", parser.textNode);
|
|
parser.textNode = "";
|
|
}
|
|
function textopts(opt, text) {
|
|
if (opt.trim)
|
|
text = text.trim();
|
|
if (opt.normalize)
|
|
text = text.replace(/\s+/g, " ");
|
|
return text;
|
|
}
|
|
function error(parser, er) {
|
|
closeText(parser);
|
|
if (parser.trackPosition)
|
|
er += "\nLine: " + parser.line + "\nColumn: " + parser.column + "\nChar: " + parser.c;
|
|
er = new Error(er);
|
|
parser.error = er;
|
|
emit(parser, "onerror", er);
|
|
return parser;
|
|
}
|
|
function end(parser) {
|
|
if (parser.sawRoot && !parser.closedRoot)
|
|
strictFail(parser, "Unclosed root tag");
|
|
if (parser.state !== S.BEGIN && parser.state !== S.BEGIN_WHITESPACE && parser.state !== S.TEXT)
|
|
error(parser, "Unexpected end");
|
|
closeText(parser);
|
|
parser.c = "";
|
|
parser.closed = true;
|
|
emit(parser, "onend");
|
|
SAXParser.call(parser, parser.strict, parser.opt);
|
|
return parser;
|
|
}
|
|
function strictFail(parser, message) {
|
|
if (typeof parser !== "object" || !(parser instanceof SAXParser))
|
|
throw new Error("bad call to strictFail");
|
|
if (parser.strict)
|
|
error(parser, message);
|
|
}
|
|
function newTag(parser) {
|
|
if (!parser.strict)
|
|
parser.tagName = parser.tagName[parser.looseCase]();
|
|
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
var tag = parser.tag = { name: parser.tagName, attributes: {} };
|
|
if (parser.opt.xmlns)
|
|
tag.ns = parent.ns;
|
|
parser.attribList.length = 0;
|
|
emitNode(parser, "onopentagstart", tag);
|
|
}
|
|
function qname(name, attribute) {
|
|
var i = name.indexOf(":");
|
|
var qualName = i < 0 ? ["", name] : name.split(":");
|
|
var prefix = qualName[0];
|
|
var local = qualName[1];
|
|
if (attribute && name === "xmlns") {
|
|
prefix = "xmlns";
|
|
local = "";
|
|
}
|
|
return { prefix, local };
|
|
}
|
|
function attrib(parser) {
|
|
if (!parser.strict)
|
|
parser.attribName = parser.attribName[parser.looseCase]();
|
|
if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
|
|
parser.attribName = parser.attribValue = "";
|
|
return;
|
|
}
|
|
if (parser.opt.xmlns) {
|
|
var qn = qname(parser.attribName, true);
|
|
var prefix = qn.prefix;
|
|
var local = qn.local;
|
|
if (prefix === "xmlns")
|
|
if (local === "xml" && parser.attribValue !== XML_NAMESPACE)
|
|
strictFail(parser, "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE)
|
|
strictFail(parser, "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue);
|
|
else {
|
|
var tag = parser.tag;
|
|
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
if (tag.ns === parent.ns)
|
|
tag.ns = Object.create(parent.ns);
|
|
tag.ns[local] = parser.attribValue;
|
|
}
|
|
parser.attribList.push([parser.attribName, parser.attribValue]);
|
|
} else {
|
|
parser.tag.attributes[parser.attribName] = parser.attribValue;
|
|
emitNode(parser, "onattribute", {
|
|
name: parser.attribName,
|
|
value: parser.attribValue
|
|
});
|
|
}
|
|
parser.attribName = parser.attribValue = "";
|
|
}
|
|
function openTag(parser, selfClosing) {
|
|
if (parser.opt.xmlns) {
|
|
var tag = parser.tag;
|
|
var qn = qname(parser.tagName);
|
|
tag.prefix = qn.prefix;
|
|
tag.local = qn.local;
|
|
tag.uri = tag.ns[qn.prefix] || "";
|
|
if (tag.prefix && !tag.uri) {
|
|
strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(parser.tagName));
|
|
tag.uri = qn.prefix;
|
|
}
|
|
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
if (tag.ns && parent.ns !== tag.ns)
|
|
Object.keys(tag.ns).forEach(function(p) {
|
|
emitNode(parser, "onopennamespace", {
|
|
prefix: p,
|
|
uri: tag.ns[p]
|
|
});
|
|
});
|
|
for (var i = 0, l = parser.attribList.length;i < l; i++) {
|
|
var nv = parser.attribList[i];
|
|
var name = nv[0];
|
|
var value = nv[1];
|
|
var qualName = qname(name, true);
|
|
var prefix = qualName.prefix;
|
|
var local = qualName.local;
|
|
var uri = prefix === "" ? "" : tag.ns[prefix] || "";
|
|
var a = {
|
|
name,
|
|
value,
|
|
prefix,
|
|
local,
|
|
uri
|
|
};
|
|
if (prefix && prefix !== "xmlns" && !uri) {
|
|
strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(prefix));
|
|
a.uri = prefix;
|
|
}
|
|
parser.tag.attributes[name] = a;
|
|
emitNode(parser, "onattribute", a);
|
|
}
|
|
parser.attribList.length = 0;
|
|
}
|
|
parser.tag.isSelfClosing = !!selfClosing;
|
|
parser.sawRoot = true;
|
|
parser.tags.push(parser.tag);
|
|
emitNode(parser, "onopentag", parser.tag);
|
|
if (!selfClosing) {
|
|
if (!parser.noscript && parser.tagName.toLowerCase() === "script")
|
|
parser.state = S.SCRIPT;
|
|
else
|
|
parser.state = S.TEXT;
|
|
parser.tag = null;
|
|
parser.tagName = "";
|
|
}
|
|
parser.attribName = parser.attribValue = "";
|
|
parser.attribList.length = 0;
|
|
}
|
|
function closeTag(parser) {
|
|
if (!parser.tagName) {
|
|
strictFail(parser, "Weird empty close tag.");
|
|
parser.textNode += "</>";
|
|
parser.state = S.TEXT;
|
|
return;
|
|
}
|
|
if (parser.script) {
|
|
if (parser.tagName !== "script") {
|
|
parser.script += "</" + parser.tagName + ">";
|
|
parser.tagName = "";
|
|
parser.state = S.SCRIPT;
|
|
return;
|
|
}
|
|
emitNode(parser, "onscript", parser.script);
|
|
parser.script = "";
|
|
}
|
|
var t = parser.tags.length;
|
|
var tagName = parser.tagName;
|
|
if (!parser.strict)
|
|
tagName = tagName[parser.looseCase]();
|
|
var closeTo = tagName;
|
|
while (t--) {
|
|
var close = parser.tags[t];
|
|
if (close.name !== closeTo)
|
|
strictFail(parser, "Unexpected close tag");
|
|
else
|
|
break;
|
|
}
|
|
if (t < 0) {
|
|
strictFail(parser, "Unmatched closing tag: " + parser.tagName);
|
|
parser.textNode += "</" + parser.tagName + ">";
|
|
parser.state = S.TEXT;
|
|
return;
|
|
}
|
|
parser.tagName = tagName;
|
|
var s2 = parser.tags.length;
|
|
while (s2-- > t) {
|
|
var tag = parser.tag = parser.tags.pop();
|
|
parser.tagName = parser.tag.name;
|
|
emitNode(parser, "onclosetag", parser.tagName);
|
|
var x = {};
|
|
for (var i in tag.ns)
|
|
x[i] = tag.ns[i];
|
|
var parent = parser.tags[parser.tags.length - 1] || parser;
|
|
if (parser.opt.xmlns && tag.ns !== parent.ns)
|
|
Object.keys(tag.ns).forEach(function(p) {
|
|
var n = tag.ns[p];
|
|
emitNode(parser, "onclosenamespace", { prefix: p, uri: n });
|
|
});
|
|
}
|
|
if (t === 0)
|
|
parser.closedRoot = true;
|
|
parser.tagName = parser.attribValue = parser.attribName = "";
|
|
parser.attribList.length = 0;
|
|
parser.state = S.TEXT;
|
|
}
|
|
function parseEntity(parser) {
|
|
var entity = parser.entity;
|
|
var entityLC = entity.toLowerCase();
|
|
var num;
|
|
var numStr = "";
|
|
if (parser.ENTITIES[entity])
|
|
return parser.ENTITIES[entity];
|
|
if (parser.ENTITIES[entityLC])
|
|
return parser.ENTITIES[entityLC];
|
|
entity = entityLC;
|
|
if (entity.charAt(0) === "#")
|
|
if (entity.charAt(1) === "x") {
|
|
entity = entity.slice(2);
|
|
num = parseInt(entity, 16);
|
|
numStr = num.toString(16);
|
|
} else {
|
|
entity = entity.slice(1);
|
|
num = parseInt(entity, 10);
|
|
numStr = num.toString(10);
|
|
}
|
|
entity = entity.replace(/^0+/, "");
|
|
if (isNaN(num) || numStr.toLowerCase() !== entity) {
|
|
strictFail(parser, "Invalid character entity");
|
|
return "&" + parser.entity + ";";
|
|
}
|
|
return String.fromCodePoint(num);
|
|
}
|
|
function beginWhiteSpace(parser, c) {
|
|
if (c === "<") {
|
|
parser.state = S.OPEN_WAKA;
|
|
parser.startTagPosition = parser.position;
|
|
} else if (!isWhitespace(c)) {
|
|
strictFail(parser, "Non-whitespace before first tag.");
|
|
parser.textNode = c;
|
|
parser.state = S.TEXT;
|
|
}
|
|
}
|
|
function charAt(chunk, i) {
|
|
var result = "";
|
|
if (i < chunk.length)
|
|
result = chunk.charAt(i);
|
|
return result;
|
|
}
|
|
function write(chunk) {
|
|
var parser = this;
|
|
if (this.error)
|
|
throw this.error;
|
|
if (parser.closed)
|
|
return error(parser, "Cannot write after close. Assign an onready handler.");
|
|
if (chunk === null)
|
|
return end(parser);
|
|
if (typeof chunk === "object")
|
|
chunk = chunk.toString();
|
|
var i = 0;
|
|
var c = "";
|
|
while (true) {
|
|
c = charAt(chunk, i++);
|
|
parser.c = c;
|
|
if (!c)
|
|
break;
|
|
if (parser.trackPosition) {
|
|
parser.position++;
|
|
if (c === "\n") {
|
|
parser.line++;
|
|
parser.column = 0;
|
|
} else
|
|
parser.column++;
|
|
}
|
|
switch (parser.state) {
|
|
case S.BEGIN:
|
|
parser.state = S.BEGIN_WHITESPACE;
|
|
if (c === "\uFEFF")
|
|
continue;
|
|
beginWhiteSpace(parser, c);
|
|
continue;
|
|
case S.BEGIN_WHITESPACE:
|
|
beginWhiteSpace(parser, c);
|
|
continue;
|
|
case S.TEXT:
|
|
if (parser.sawRoot && !parser.closedRoot) {
|
|
var starti = i - 1;
|
|
while (c && c !== "<" && c !== "&") {
|
|
c = charAt(chunk, i++);
|
|
if (c && parser.trackPosition) {
|
|
parser.position++;
|
|
if (c === "\n") {
|
|
parser.line++;
|
|
parser.column = 0;
|
|
} else
|
|
parser.column++;
|
|
}
|
|
}
|
|
parser.textNode += chunk.substring(starti, i - 1);
|
|
}
|
|
if (c === "<" && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
|
|
parser.state = S.OPEN_WAKA;
|
|
parser.startTagPosition = parser.position;
|
|
} else {
|
|
if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot))
|
|
strictFail(parser, "Text data outside of root node.");
|
|
if (c === "&")
|
|
parser.state = S.TEXT_ENTITY;
|
|
else
|
|
parser.textNode += c;
|
|
}
|
|
continue;
|
|
case S.SCRIPT:
|
|
if (c === "<")
|
|
parser.state = S.SCRIPT_ENDING;
|
|
else
|
|
parser.script += c;
|
|
continue;
|
|
case S.SCRIPT_ENDING:
|
|
if (c === "/")
|
|
parser.state = S.CLOSE_TAG;
|
|
else {
|
|
parser.script += "<" + c;
|
|
parser.state = S.SCRIPT;
|
|
}
|
|
continue;
|
|
case S.OPEN_WAKA:
|
|
if (c === "!") {
|
|
parser.state = S.SGML_DECL;
|
|
parser.sgmlDecl = "";
|
|
} else if (isWhitespace(c))
|
|
;
|
|
else if (isMatch(nameStart, c)) {
|
|
parser.state = S.OPEN_TAG;
|
|
parser.tagName = c;
|
|
} else if (c === "/") {
|
|
parser.state = S.CLOSE_TAG;
|
|
parser.tagName = "";
|
|
} else if (c === "?") {
|
|
parser.state = S.PROC_INST;
|
|
parser.procInstName = parser.procInstBody = "";
|
|
} else {
|
|
strictFail(parser, "Unencoded <");
|
|
if (parser.startTagPosition + 1 < parser.position) {
|
|
var pad = parser.position - parser.startTagPosition;
|
|
c = new Array(pad).join(" ") + c;
|
|
}
|
|
parser.textNode += "<" + c;
|
|
parser.state = S.TEXT;
|
|
}
|
|
continue;
|
|
case S.SGML_DECL:
|
|
if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
|
|
emitNode(parser, "onopencdata");
|
|
parser.state = S.CDATA;
|
|
parser.sgmlDecl = "";
|
|
parser.cdata = "";
|
|
} else if (parser.sgmlDecl + c === "--") {
|
|
parser.state = S.COMMENT;
|
|
parser.comment = "";
|
|
parser.sgmlDecl = "";
|
|
} else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
|
|
parser.state = S.DOCTYPE;
|
|
if (parser.doctype || parser.sawRoot)
|
|
strictFail(parser, "Inappropriately located doctype declaration");
|
|
parser.doctype = "";
|
|
parser.sgmlDecl = "";
|
|
} else if (c === ">") {
|
|
emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
|
|
parser.sgmlDecl = "";
|
|
parser.state = S.TEXT;
|
|
} else if (isQuote(c)) {
|
|
parser.state = S.SGML_DECL_QUOTED;
|
|
parser.sgmlDecl += c;
|
|
} else
|
|
parser.sgmlDecl += c;
|
|
continue;
|
|
case S.SGML_DECL_QUOTED:
|
|
if (c === parser.q) {
|
|
parser.state = S.SGML_DECL;
|
|
parser.q = "";
|
|
}
|
|
parser.sgmlDecl += c;
|
|
continue;
|
|
case S.DOCTYPE:
|
|
if (c === ">") {
|
|
parser.state = S.TEXT;
|
|
emitNode(parser, "ondoctype", parser.doctype);
|
|
parser.doctype = true;
|
|
} else {
|
|
parser.doctype += c;
|
|
if (c === "[")
|
|
parser.state = S.DOCTYPE_DTD;
|
|
else if (isQuote(c)) {
|
|
parser.state = S.DOCTYPE_QUOTED;
|
|
parser.q = c;
|
|
}
|
|
}
|
|
continue;
|
|
case S.DOCTYPE_QUOTED:
|
|
parser.doctype += c;
|
|
if (c === parser.q) {
|
|
parser.q = "";
|
|
parser.state = S.DOCTYPE;
|
|
}
|
|
continue;
|
|
case S.DOCTYPE_DTD:
|
|
parser.doctype += c;
|
|
if (c === "]")
|
|
parser.state = S.DOCTYPE;
|
|
else if (isQuote(c)) {
|
|
parser.state = S.DOCTYPE_DTD_QUOTED;
|
|
parser.q = c;
|
|
}
|
|
continue;
|
|
case S.DOCTYPE_DTD_QUOTED:
|
|
parser.doctype += c;
|
|
if (c === parser.q) {
|
|
parser.state = S.DOCTYPE_DTD;
|
|
parser.q = "";
|
|
}
|
|
continue;
|
|
case S.COMMENT:
|
|
if (c === "-")
|
|
parser.state = S.COMMENT_ENDING;
|
|
else
|
|
parser.comment += c;
|
|
continue;
|
|
case S.COMMENT_ENDING:
|
|
if (c === "-") {
|
|
parser.state = S.COMMENT_ENDED;
|
|
parser.comment = textopts(parser.opt, parser.comment);
|
|
if (parser.comment)
|
|
emitNode(parser, "oncomment", parser.comment);
|
|
parser.comment = "";
|
|
} else {
|
|
parser.comment += "-" + c;
|
|
parser.state = S.COMMENT;
|
|
}
|
|
continue;
|
|
case S.COMMENT_ENDED:
|
|
if (c !== ">") {
|
|
strictFail(parser, "Malformed comment");
|
|
parser.comment += "--" + c;
|
|
parser.state = S.COMMENT;
|
|
} else
|
|
parser.state = S.TEXT;
|
|
continue;
|
|
case S.CDATA:
|
|
if (c === "]")
|
|
parser.state = S.CDATA_ENDING;
|
|
else
|
|
parser.cdata += c;
|
|
continue;
|
|
case S.CDATA_ENDING:
|
|
if (c === "]")
|
|
parser.state = S.CDATA_ENDING_2;
|
|
else {
|
|
parser.cdata += "]" + c;
|
|
parser.state = S.CDATA;
|
|
}
|
|
continue;
|
|
case S.CDATA_ENDING_2:
|
|
if (c === ">") {
|
|
if (parser.cdata)
|
|
emitNode(parser, "oncdata", parser.cdata);
|
|
emitNode(parser, "onclosecdata");
|
|
parser.cdata = "";
|
|
parser.state = S.TEXT;
|
|
} else if (c === "]")
|
|
parser.cdata += "]";
|
|
else {
|
|
parser.cdata += "]]" + c;
|
|
parser.state = S.CDATA;
|
|
}
|
|
continue;
|
|
case S.PROC_INST:
|
|
if (c === "?")
|
|
parser.state = S.PROC_INST_ENDING;
|
|
else if (isWhitespace(c))
|
|
parser.state = S.PROC_INST_BODY;
|
|
else
|
|
parser.procInstName += c;
|
|
continue;
|
|
case S.PROC_INST_BODY:
|
|
if (!parser.procInstBody && isWhitespace(c))
|
|
continue;
|
|
else if (c === "?")
|
|
parser.state = S.PROC_INST_ENDING;
|
|
else
|
|
parser.procInstBody += c;
|
|
continue;
|
|
case S.PROC_INST_ENDING:
|
|
if (c === ">") {
|
|
emitNode(parser, "onprocessinginstruction", {
|
|
name: parser.procInstName,
|
|
body: parser.procInstBody
|
|
});
|
|
parser.procInstName = parser.procInstBody = "";
|
|
parser.state = S.TEXT;
|
|
} else {
|
|
parser.procInstBody += "?" + c;
|
|
parser.state = S.PROC_INST_BODY;
|
|
}
|
|
continue;
|
|
case S.OPEN_TAG:
|
|
if (isMatch(nameBody, c))
|
|
parser.tagName += c;
|
|
else {
|
|
newTag(parser);
|
|
if (c === ">")
|
|
openTag(parser);
|
|
else if (c === "/")
|
|
parser.state = S.OPEN_TAG_SLASH;
|
|
else {
|
|
if (!isWhitespace(c))
|
|
strictFail(parser, "Invalid character in tag name");
|
|
parser.state = S.ATTRIB;
|
|
}
|
|
}
|
|
continue;
|
|
case S.OPEN_TAG_SLASH:
|
|
if (c === ">") {
|
|
openTag(parser, true);
|
|
closeTag(parser);
|
|
} else {
|
|
strictFail(parser, "Forward-slash in opening tag not followed by >");
|
|
parser.state = S.ATTRIB;
|
|
}
|
|
continue;
|
|
case S.ATTRIB:
|
|
if (isWhitespace(c))
|
|
continue;
|
|
else if (c === ">")
|
|
openTag(parser);
|
|
else if (c === "/")
|
|
parser.state = S.OPEN_TAG_SLASH;
|
|
else if (isMatch(nameStart, c)) {
|
|
parser.attribName = c;
|
|
parser.attribValue = "";
|
|
parser.state = S.ATTRIB_NAME;
|
|
} else
|
|
strictFail(parser, "Invalid attribute name");
|
|
continue;
|
|
case S.ATTRIB_NAME:
|
|
if (c === "=")
|
|
parser.state = S.ATTRIB_VALUE;
|
|
else if (c === ">") {
|
|
strictFail(parser, "Attribute without value");
|
|
parser.attribValue = parser.attribName;
|
|
attrib(parser);
|
|
openTag(parser);
|
|
} else if (isWhitespace(c))
|
|
parser.state = S.ATTRIB_NAME_SAW_WHITE;
|
|
else if (isMatch(nameBody, c))
|
|
parser.attribName += c;
|
|
else
|
|
strictFail(parser, "Invalid attribute name");
|
|
continue;
|
|
case S.ATTRIB_NAME_SAW_WHITE:
|
|
if (c === "=")
|
|
parser.state = S.ATTRIB_VALUE;
|
|
else if (isWhitespace(c))
|
|
continue;
|
|
else {
|
|
strictFail(parser, "Attribute without value");
|
|
parser.tag.attributes[parser.attribName] = "";
|
|
parser.attribValue = "";
|
|
emitNode(parser, "onattribute", {
|
|
name: parser.attribName,
|
|
value: ""
|
|
});
|
|
parser.attribName = "";
|
|
if (c === ">")
|
|
openTag(parser);
|
|
else if (isMatch(nameStart, c)) {
|
|
parser.attribName = c;
|
|
parser.state = S.ATTRIB_NAME;
|
|
} else {
|
|
strictFail(parser, "Invalid attribute name");
|
|
parser.state = S.ATTRIB;
|
|
}
|
|
}
|
|
continue;
|
|
case S.ATTRIB_VALUE:
|
|
if (isWhitespace(c))
|
|
continue;
|
|
else if (isQuote(c)) {
|
|
parser.q = c;
|
|
parser.state = S.ATTRIB_VALUE_QUOTED;
|
|
} else {
|
|
strictFail(parser, "Unquoted attribute value");
|
|
parser.state = S.ATTRIB_VALUE_UNQUOTED;
|
|
parser.attribValue = c;
|
|
}
|
|
continue;
|
|
case S.ATTRIB_VALUE_QUOTED:
|
|
if (c !== parser.q) {
|
|
if (c === "&")
|
|
parser.state = S.ATTRIB_VALUE_ENTITY_Q;
|
|
else
|
|
parser.attribValue += c;
|
|
continue;
|
|
}
|
|
attrib(parser);
|
|
parser.q = "";
|
|
parser.state = S.ATTRIB_VALUE_CLOSED;
|
|
continue;
|
|
case S.ATTRIB_VALUE_CLOSED:
|
|
if (isWhitespace(c))
|
|
parser.state = S.ATTRIB;
|
|
else if (c === ">")
|
|
openTag(parser);
|
|
else if (c === "/")
|
|
parser.state = S.OPEN_TAG_SLASH;
|
|
else if (isMatch(nameStart, c)) {
|
|
strictFail(parser, "No whitespace between attributes");
|
|
parser.attribName = c;
|
|
parser.attribValue = "";
|
|
parser.state = S.ATTRIB_NAME;
|
|
} else
|
|
strictFail(parser, "Invalid attribute name");
|
|
continue;
|
|
case S.ATTRIB_VALUE_UNQUOTED:
|
|
if (!isAttribEnd(c)) {
|
|
if (c === "&")
|
|
parser.state = S.ATTRIB_VALUE_ENTITY_U;
|
|
else
|
|
parser.attribValue += c;
|
|
continue;
|
|
}
|
|
attrib(parser);
|
|
if (c === ">")
|
|
openTag(parser);
|
|
else
|
|
parser.state = S.ATTRIB;
|
|
continue;
|
|
case S.CLOSE_TAG:
|
|
if (!parser.tagName)
|
|
if (isWhitespace(c))
|
|
continue;
|
|
else if (notMatch(nameStart, c))
|
|
if (parser.script) {
|
|
parser.script += "</" + c;
|
|
parser.state = S.SCRIPT;
|
|
} else
|
|
strictFail(parser, "Invalid tagname in closing tag.");
|
|
else
|
|
parser.tagName = c;
|
|
else if (c === ">")
|
|
closeTag(parser);
|
|
else if (isMatch(nameBody, c))
|
|
parser.tagName += c;
|
|
else if (parser.script) {
|
|
parser.script += "</" + parser.tagName;
|
|
parser.tagName = "";
|
|
parser.state = S.SCRIPT;
|
|
} else {
|
|
if (!isWhitespace(c))
|
|
strictFail(parser, "Invalid tagname in closing tag");
|
|
parser.state = S.CLOSE_TAG_SAW_WHITE;
|
|
}
|
|
continue;
|
|
case S.CLOSE_TAG_SAW_WHITE:
|
|
if (isWhitespace(c))
|
|
continue;
|
|
if (c === ">")
|
|
closeTag(parser);
|
|
else
|
|
strictFail(parser, "Invalid characters in closing tag");
|
|
continue;
|
|
case S.TEXT_ENTITY:
|
|
case S.ATTRIB_VALUE_ENTITY_Q:
|
|
case S.ATTRIB_VALUE_ENTITY_U:
|
|
var returnState;
|
|
var buffer;
|
|
switch (parser.state) {
|
|
case S.TEXT_ENTITY:
|
|
returnState = S.TEXT;
|
|
buffer = "textNode";
|
|
break;
|
|
case S.ATTRIB_VALUE_ENTITY_Q:
|
|
returnState = S.ATTRIB_VALUE_QUOTED;
|
|
buffer = "attribValue";
|
|
break;
|
|
case S.ATTRIB_VALUE_ENTITY_U:
|
|
returnState = S.ATTRIB_VALUE_UNQUOTED;
|
|
buffer = "attribValue";
|
|
break;
|
|
}
|
|
if (c === ";") {
|
|
parser[buffer] += parseEntity(parser);
|
|
parser.entity = "";
|
|
parser.state = returnState;
|
|
} else if (isMatch(parser.entity.length ? entityBody : entityStart, c))
|
|
parser.entity += c;
|
|
else {
|
|
strictFail(parser, "Invalid character in entity name");
|
|
parser[buffer] += "&" + parser.entity + c;
|
|
parser.entity = "";
|
|
parser.state = returnState;
|
|
}
|
|
continue;
|
|
default:
|
|
throw new Error(parser, "Unknown state: " + parser.state);
|
|
}
|
|
}
|
|
if (parser.position >= parser.bufferCheckPosition)
|
|
checkBufferLength(parser);
|
|
return parser;
|
|
}
|
|
/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
|
|
if (!String.fromCodePoint)
|
|
(function() {
|
|
var stringFromCharCode = String.fromCharCode;
|
|
var floor = Math.floor;
|
|
var fromCodePoint = function() {
|
|
var MAX_SIZE = 16384;
|
|
var codeUnits = [];
|
|
var highSurrogate;
|
|
var lowSurrogate;
|
|
var index = -1;
|
|
var length = arguments.length;
|
|
if (!length)
|
|
return "";
|
|
var result = "";
|
|
while (++index < length) {
|
|
var codePoint = Number(arguments[index]);
|
|
if (!isFinite(codePoint) || codePoint < 0 || codePoint > 1114111 || floor(codePoint) !== codePoint)
|
|
throw RangeError("Invalid code point: " + codePoint);
|
|
if (codePoint <= 65535)
|
|
codeUnits.push(codePoint);
|
|
else {
|
|
codePoint -= 65536;
|
|
highSurrogate = (codePoint >> 10) + 55296;
|
|
lowSurrogate = codePoint % 1024 + 56320;
|
|
codeUnits.push(highSurrogate, lowSurrogate);
|
|
}
|
|
if (index + 1 === length || codeUnits.length > MAX_SIZE) {
|
|
result += stringFromCharCode.apply(null, codeUnits);
|
|
codeUnits.length = 0;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
if (Object.defineProperty)
|
|
Object.defineProperty(String, "fromCodePoint", {
|
|
value: fromCodePoint,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
else
|
|
String.fromCodePoint = fromCodePoint;
|
|
})();
|
|
})(typeof exports === "undefined" ? exports.sax = {} : exports);
|
|
});
|
|
|
|
// node_modules/xml2js/lib/bom.js
|
|
var require_bom = __commonJS((exports) => {
|
|
(function() {
|
|
exports.stripBOM = function(str) {
|
|
if (str[0] === "\uFEFF")
|
|
return str.substring(1);
|
|
else
|
|
return str;
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xml2js/lib/processors.js
|
|
var require_processors = __commonJS((exports) => {
|
|
(function() {
|
|
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(exports);
|
|
});
|
|
|
|
// node_modules/xml2js/lib/parser.js
|
|
var require_parser = __commonJS((exports) => {
|
|
(function() {
|
|
var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate2, bind = function(fn, me) {
|
|
return function() {
|
|
return fn.apply(me, arguments);
|
|
};
|
|
}, 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;
|
|
sax = require_sax();
|
|
events = __require("events");
|
|
bom = require_bom();
|
|
processors = require_processors();
|
|
setImmediate2 = __require("timers").setImmediate;
|
|
defaults = require_defaults().defaults;
|
|
isEmpty = function(thing) {
|
|
return typeof thing === "object" && thing != null && Object.keys(thing).length === 0;
|
|
};
|
|
processItem = function(processors2, item, key) {
|
|
var i, len, process2;
|
|
for (i = 0, len = processors2.length;i < len; i++) {
|
|
process2 = processors2[i];
|
|
item = process2(item, key);
|
|
}
|
|
return item;
|
|
};
|
|
exports.Parser = function(superClass) {
|
|
extend(Parser, superClass);
|
|
function Parser(opts) {
|
|
this.parseStringPromise = bind(this.parseStringPromise, this);
|
|
this.parseString = bind(this.parseString, this);
|
|
this.reset = bind(this.reset, this);
|
|
this.assignOrPush = bind(this.assignOrPush, this);
|
|
this.processAsync = bind(this.processAsync, this);
|
|
var key, ref, value;
|
|
if (!(this instanceof exports.Parser))
|
|
return new exports.Parser(opts);
|
|
this.options = {};
|
|
ref = defaults["0.2"];
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key))
|
|
continue;
|
|
value = ref[key];
|
|
this.options[key] = value;
|
|
}
|
|
for (key in opts) {
|
|
if (!hasProp.call(opts, key))
|
|
continue;
|
|
value = opts[key];
|
|
this.options[key] = value;
|
|
}
|
|
if (this.options.xmlns)
|
|
this.options.xmlnskey = this.options.attrkey + "ns";
|
|
if (this.options.normalizeTags) {
|
|
if (!this.options.tagNameProcessors)
|
|
this.options.tagNameProcessors = [];
|
|
this.options.tagNameProcessors.unshift(processors.normalize);
|
|
}
|
|
this.reset();
|
|
}
|
|
Parser.prototype.processAsync = function() {
|
|
var chunk, err;
|
|
try {
|
|
if (this.remaining.length <= this.options.chunkSize) {
|
|
chunk = this.remaining;
|
|
this.remaining = "";
|
|
this.saxParser = this.saxParser.write(chunk);
|
|
return this.saxParser.close();
|
|
} else {
|
|
chunk = this.remaining.substr(0, this.options.chunkSize);
|
|
this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
|
|
this.saxParser = this.saxParser.write(chunk);
|
|
return setImmediate2(this.processAsync);
|
|
}
|
|
} catch (error1) {
|
|
err = error1;
|
|
if (!this.saxParser.errThrown) {
|
|
this.saxParser.errThrown = true;
|
|
return this.emit(err);
|
|
}
|
|
}
|
|
};
|
|
Parser.prototype.assignOrPush = function(obj, key, newValue) {
|
|
if (!(key in obj))
|
|
if (!this.options.explicitArray)
|
|
return obj[key] = newValue;
|
|
else
|
|
return obj[key] = [newValue];
|
|
else {
|
|
if (!(obj[key] instanceof Array))
|
|
obj[key] = [obj[key]];
|
|
return obj[key].push(newValue);
|
|
}
|
|
};
|
|
Parser.prototype.reset = function() {
|
|
var attrkey, charkey, ontext, stack;
|
|
this.removeAllListeners();
|
|
this.saxParser = sax.parser(this.options.strict, {
|
|
trim: false,
|
|
normalize: false,
|
|
xmlns: this.options.xmlns
|
|
});
|
|
this.saxParser.errThrown = false;
|
|
this.saxParser.onerror = function(_this) {
|
|
return function(error) {
|
|
_this.saxParser.resume();
|
|
if (!_this.saxParser.errThrown) {
|
|
_this.saxParser.errThrown = true;
|
|
return _this.emit("error", error);
|
|
}
|
|
};
|
|
}(this);
|
|
this.saxParser.onend = function(_this) {
|
|
return function() {
|
|
if (!_this.saxParser.ended) {
|
|
_this.saxParser.ended = true;
|
|
return _this.emit("end", _this.resultObject);
|
|
}
|
|
};
|
|
}(this);
|
|
this.saxParser.ended = false;
|
|
this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
|
|
this.resultObject = null;
|
|
stack = [];
|
|
attrkey = this.options.attrkey;
|
|
charkey = this.options.charkey;
|
|
this.saxParser.onopentag = function(_this) {
|
|
return function(node) {
|
|
var key, newValue, obj, processedKey, ref;
|
|
obj = Object.create(null);
|
|
obj[charkey] = "";
|
|
if (!_this.options.ignoreAttrs) {
|
|
ref = node.attributes;
|
|
for (key in ref) {
|
|
if (!hasProp.call(ref, key))
|
|
continue;
|
|
if (!(attrkey in obj) && !_this.options.mergeAttrs)
|
|
obj[attrkey] = Object.create(null);
|
|
newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];
|
|
processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;
|
|
if (_this.options.mergeAttrs)
|
|
_this.assignOrPush(obj, processedKey, newValue);
|
|
else
|
|
obj[attrkey][processedKey] = newValue;
|
|
}
|
|
}
|
|
obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;
|
|
if (_this.options.xmlns)
|
|
obj[_this.options.xmlnskey] = {
|
|
uri: node.uri,
|
|
local: node.local
|
|
};
|
|
return stack.push(obj);
|
|
};
|
|
}(this);
|
|
this.saxParser.onclosetag = function(_this) {
|
|
return function() {
|
|
var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath;
|
|
obj = stack.pop();
|
|
nodeName = obj["#name"];
|
|
if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder)
|
|
delete obj["#name"];
|
|
if (obj.cdata === true) {
|
|
cdata = obj.cdata;
|
|
delete obj.cdata;
|
|
}
|
|
s = stack[stack.length - 1];
|
|
if (obj[charkey].match(/^\s*$/) && !cdata) {
|
|
emptyStr = obj[charkey];
|
|
delete obj[charkey];
|
|
} else {
|
|
if (_this.options.trim)
|
|
obj[charkey] = obj[charkey].trim();
|
|
if (_this.options.normalize)
|
|
obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
|
|
obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];
|
|
if (Object.keys(obj).length === 1 && (charkey in obj) && !_this.EXPLICIT_CHARKEY)
|
|
obj = obj[charkey];
|
|
}
|
|
if (isEmpty(obj))
|
|
if (typeof _this.options.emptyTag === "function")
|
|
obj = _this.options.emptyTag();
|
|
else
|
|
obj = _this.options.emptyTag !== "" ? _this.options.emptyTag : emptyStr;
|
|
if (_this.options.validator != null) {
|
|
xpath = "/" + function() {
|
|
var i, len, results;
|
|
results = [];
|
|
for (i = 0, len = stack.length;i < len; i++) {
|
|
node = stack[i];
|
|
results.push(node["#name"]);
|
|
}
|
|
return results;
|
|
}().concat(nodeName).join("/");
|
|
(function() {
|
|
var err;
|
|
try {
|
|
return obj = _this.options.validator(xpath, s && s[nodeName], obj);
|
|
} catch (error1) {
|
|
err = error1;
|
|
return _this.emit("error", err);
|
|
}
|
|
})();
|
|
}
|
|
if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === "object") {
|
|
if (!_this.options.preserveChildrenOrder) {
|
|
node = Object.create(null);
|
|
if (_this.options.attrkey in obj) {
|
|
node[_this.options.attrkey] = obj[_this.options.attrkey];
|
|
delete obj[_this.options.attrkey];
|
|
}
|
|
if (!_this.options.charsAsChildren && (_this.options.charkey in obj)) {
|
|
node[_this.options.charkey] = obj[_this.options.charkey];
|
|
delete obj[_this.options.charkey];
|
|
}
|
|
if (Object.getOwnPropertyNames(obj).length > 0)
|
|
node[_this.options.childkey] = obj;
|
|
obj = node;
|
|
} else if (s) {
|
|
s[_this.options.childkey] = s[_this.options.childkey] || [];
|
|
objClone = Object.create(null);
|
|
for (key in obj) {
|
|
if (!hasProp.call(obj, key))
|
|
continue;
|
|
objClone[key] = obj[key];
|
|
}
|
|
s[_this.options.childkey].push(objClone);
|
|
delete obj["#name"];
|
|
if (Object.keys(obj).length === 1 && (charkey in obj) && !_this.EXPLICIT_CHARKEY)
|
|
obj = obj[charkey];
|
|
}
|
|
}
|
|
if (stack.length > 0)
|
|
return _this.assignOrPush(s, nodeName, obj);
|
|
else {
|
|
if (_this.options.explicitRoot) {
|
|
old = obj;
|
|
obj = Object.create(null);
|
|
obj[nodeName] = old;
|
|
}
|
|
_this.resultObject = obj;
|
|
_this.saxParser.ended = true;
|
|
return _this.emit("end", _this.resultObject);
|
|
}
|
|
};
|
|
}(this);
|
|
ontext = function(_this) {
|
|
return function(text) {
|
|
var charChild, s;
|
|
s = stack[stack.length - 1];
|
|
if (s) {
|
|
s[charkey] += text;
|
|
if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, "").trim() !== "")) {
|
|
s[_this.options.childkey] = s[_this.options.childkey] || [];
|
|
charChild = {
|
|
"#name": "__text__"
|
|
};
|
|
charChild[charkey] = text;
|
|
if (_this.options.normalize)
|
|
charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
|
|
s[_this.options.childkey].push(charChild);
|
|
}
|
|
return s;
|
|
}
|
|
};
|
|
}(this);
|
|
this.saxParser.ontext = ontext;
|
|
return this.saxParser.oncdata = function(_this) {
|
|
return function(text) {
|
|
var s;
|
|
s = ontext(text);
|
|
if (s)
|
|
return s.cdata = true;
|
|
};
|
|
}(this);
|
|
};
|
|
Parser.prototype.parseString = function(str, cb) {
|
|
var err;
|
|
if (cb != null && typeof cb === "function") {
|
|
this.on("end", function(result) {
|
|
this.reset();
|
|
return cb(null, result);
|
|
});
|
|
this.on("error", function(err2) {
|
|
this.reset();
|
|
return cb(err2);
|
|
});
|
|
}
|
|
try {
|
|
str = str.toString();
|
|
if (str.trim() === "") {
|
|
this.emit("end", null);
|
|
return true;
|
|
}
|
|
str = bom.stripBOM(str);
|
|
if (this.options.async) {
|
|
this.remaining = str;
|
|
setImmediate2(this.processAsync);
|
|
return this.saxParser;
|
|
}
|
|
return this.saxParser.write(str).close();
|
|
} catch (error1) {
|
|
err = error1;
|
|
if (!(this.saxParser.errThrown || this.saxParser.ended)) {
|
|
this.emit("error", err);
|
|
return this.saxParser.errThrown = true;
|
|
} else if (this.saxParser.ended)
|
|
throw err;
|
|
}
|
|
};
|
|
Parser.prototype.parseStringPromise = function(str) {
|
|
return new Promise(function(_this) {
|
|
return function(resolve, reject) {
|
|
return _this.parseString(str, function(err, value) {
|
|
if (err)
|
|
return reject(err);
|
|
else
|
|
return resolve(value);
|
|
});
|
|
};
|
|
}(this));
|
|
};
|
|
return Parser;
|
|
}(events);
|
|
exports.parseString = function(str, a, b) {
|
|
var cb, options, parser;
|
|
if (b != null) {
|
|
if (typeof b === "function")
|
|
cb = b;
|
|
if (typeof a === "object")
|
|
options = a;
|
|
} else {
|
|
if (typeof a === "function")
|
|
cb = a;
|
|
options = {};
|
|
}
|
|
parser = new exports.Parser(options);
|
|
return parser.parseString(str, cb);
|
|
};
|
|
exports.parseStringPromise = function(str, a) {
|
|
var options, parser;
|
|
if (typeof a === "object")
|
|
options = a;
|
|
parser = new exports.Parser(options);
|
|
return parser.parseStringPromise(str);
|
|
};
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/xml2js/lib/xml2js.js
|
|
var require_xml2js = __commonJS((exports) => {
|
|
(function() {
|
|
var builder, defaults, parser, processors, 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;
|
|
defaults = require_defaults();
|
|
builder = require_builder();
|
|
parser = require_parser();
|
|
processors = require_processors();
|
|
exports.defaults = defaults.defaults;
|
|
exports.processors = processors;
|
|
exports.ValidationError = function(superClass) {
|
|
extend(ValidationError, superClass);
|
|
function ValidationError(message) {
|
|
this.message = message;
|
|
}
|
|
return ValidationError;
|
|
}(Error);
|
|
exports.Builder = builder.Builder;
|
|
exports.Parser = parser.Parser;
|
|
exports.parseString = parser.parseString;
|
|
exports.parseStringPromise = parser.parseStringPromise;
|
|
}).call(exports);
|
|
});
|
|
|
|
// node_modules/@azure/abort-controller/dist/index.js
|
|
var require_dist = __commonJS((exports) => {
|
|
var abortSignal = function(signal) {
|
|
if (signal.aborted)
|
|
return;
|
|
if (signal.onabort)
|
|
signal.onabort.call(signal);
|
|
const listeners = listenersMap.get(signal);
|
|
if (listeners)
|
|
listeners.slice().forEach((listener) => {
|
|
listener.call(signal, { type: "abort" });
|
|
});
|
|
abortedMap.set(signal, true);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var listenersMap = new WeakMap;
|
|
var abortedMap = new WeakMap;
|
|
|
|
class AbortSignal {
|
|
constructor() {
|
|
this.onabort = null;
|
|
listenersMap.set(this, []);
|
|
abortedMap.set(this, false);
|
|
}
|
|
get aborted() {
|
|
if (!abortedMap.has(this))
|
|
throw new TypeError("Expected `this` to be an instance of AbortSignal.");
|
|
return abortedMap.get(this);
|
|
}
|
|
static get none() {
|
|
return new AbortSignal;
|
|
}
|
|
addEventListener(_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);
|
|
}
|
|
removeEventListener(_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);
|
|
}
|
|
dispatchEvent(_event) {
|
|
throw new Error("This is a stub dispatchEvent implementation that should not be used. It only exists for type-checking purposes.");
|
|
}
|
|
}
|
|
|
|
class AbortError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "AbortError";
|
|
}
|
|
}
|
|
|
|
class AbortController {
|
|
constructor(parentSignals) {
|
|
this._signal = new AbortSignal;
|
|
if (!parentSignals)
|
|
return;
|
|
if (!Array.isArray(parentSignals))
|
|
parentSignals = arguments;
|
|
for (const parentSignal of parentSignals)
|
|
if (parentSignal.aborted)
|
|
this.abort();
|
|
else
|
|
parentSignal.addEventListener("abort", () => {
|
|
this.abort();
|
|
});
|
|
}
|
|
get signal() {
|
|
return this._signal;
|
|
}
|
|
abort() {
|
|
abortSignal(this._signal);
|
|
}
|
|
static timeout(ms) {
|
|
const signal = new AbortSignal;
|
|
const timer = setTimeout(abortSignal, ms, signal);
|
|
if (typeof timer.unref === "function")
|
|
timer.unref();
|
|
return signal;
|
|
}
|
|
}
|
|
exports.AbortController = AbortController;
|
|
exports.AbortError = AbortError;
|
|
exports.AbortSignal = AbortSignal;
|
|
});
|
|
|
|
// node_modules/@azure/core-util/dist/index.js
|
|
var require_dist2 = __commonJS((exports) => {
|
|
var createAbortablePromise = function(buildPromise, options) {
|
|
const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options !== null && options !== undefined ? options : {};
|
|
return new Promise((resolve, reject) => {
|
|
function rejectOnAbort() {
|
|
reject(new abortController.AbortError(abortErrorMsg !== null && abortErrorMsg !== undefined ? abortErrorMsg : "The operation was aborted."));
|
|
}
|
|
function removeListeners() {
|
|
abortSignal === null || abortSignal === undefined || abortSignal.removeEventListener("abort", onAbort);
|
|
}
|
|
function onAbort() {
|
|
cleanupBeforeAbort === null || cleanupBeforeAbort === undefined || cleanupBeforeAbort();
|
|
removeListeners();
|
|
rejectOnAbort();
|
|
}
|
|
if (abortSignal === null || abortSignal === undefined ? undefined : abortSignal.aborted)
|
|
return rejectOnAbort();
|
|
try {
|
|
buildPromise((x) => {
|
|
removeListeners();
|
|
resolve(x);
|
|
}, (x) => {
|
|
removeListeners();
|
|
reject(x);
|
|
});
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
abortSignal === null || abortSignal === undefined || abortSignal.addEventListener("abort", onAbort);
|
|
});
|
|
};
|
|
var delay = function(timeInMs, options) {
|
|
let token;
|
|
const { abortSignal, abortErrorMsg } = options !== null && options !== undefined ? options : {};
|
|
return createAbortablePromise((resolve) => {
|
|
token = setTimeout(resolve, timeInMs);
|
|
}, {
|
|
cleanupBeforeAbort: () => clearTimeout(token),
|
|
abortSignal,
|
|
abortErrorMsg: abortErrorMsg !== null && abortErrorMsg !== undefined ? abortErrorMsg : StandardAbortMessage
|
|
});
|
|
};
|
|
var getRandomIntegerInclusive = function(min, max) {
|
|
min = Math.ceil(min);
|
|
max = Math.floor(max);
|
|
const offset = Math.floor(Math.random() * (max - min + 1));
|
|
return offset + min;
|
|
};
|
|
var isObject = function(input) {
|
|
return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof RegExp) && !(input instanceof Date);
|
|
};
|
|
var isError = function(e) {
|
|
if (isObject(e)) {
|
|
const hasName = typeof e.name === "string";
|
|
const hasMessage = typeof e.message === "string";
|
|
return hasName && hasMessage;
|
|
}
|
|
return false;
|
|
};
|
|
var getErrorMessage = function(e) {
|
|
if (isError(e))
|
|
return e.message;
|
|
else {
|
|
let stringified;
|
|
try {
|
|
if (typeof e === "object" && e)
|
|
stringified = JSON.stringify(e);
|
|
else
|
|
stringified = String(e);
|
|
} catch (err) {
|
|
stringified = "[unable to stringify input]";
|
|
}
|
|
return `Unknown error ${stringified}`;
|
|
}
|
|
};
|
|
async function computeSha256Hmac(key, stringToSign, encoding) {
|
|
const decodedKey = Buffer.from(key, "base64");
|
|
return crypto7.createHmac("sha256", decodedKey).update(stringToSign).digest(encoding);
|
|
}
|
|
async function computeSha256Hash(content, encoding) {
|
|
return crypto7.createHash("sha256").update(content).digest(encoding);
|
|
}
|
|
var isDefined = function(thing) {
|
|
return typeof thing !== "undefined" && thing !== null;
|
|
};
|
|
var isObjectWithProperties = function(thing, properties) {
|
|
if (!isDefined(thing) || typeof thing !== "object")
|
|
return false;
|
|
for (const property of properties)
|
|
if (!objectHasProperty(thing, property))
|
|
return false;
|
|
return true;
|
|
};
|
|
var objectHasProperty = function(thing, property) {
|
|
return isDefined(thing) && typeof thing === "object" && (property in thing);
|
|
};
|
|
var generateUUID = function() {
|
|
let uuid = "";
|
|
for (let i = 0;i < 32; i++) {
|
|
const randomNumber = Math.floor(Math.random() * 16);
|
|
if (i === 12)
|
|
uuid += "4";
|
|
else if (i === 16)
|
|
uuid += randomNumber & 3 | 8;
|
|
else
|
|
uuid += randomNumber.toString(16);
|
|
if (i === 7 || i === 11 || i === 15 || i === 19)
|
|
uuid += "-";
|
|
}
|
|
return uuid;
|
|
};
|
|
var randomUUID = function() {
|
|
return uuidFunction();
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var abortController = require_dist();
|
|
var crypto7 = __require("crypto");
|
|
var _a$1;
|
|
var isNode = typeof process !== "undefined" && Boolean(process.version) && Boolean((_a$1 = process.versions) === null || _a$1 === undefined ? undefined : _a$1.node);
|
|
var StandardAbortMessage = "The delay was aborted.";
|
|
var _a;
|
|
var uuidFunction = typeof ((_a = globalThis === null || globalThis === undefined ? undefined : globalThis.crypto) === null || _a === undefined ? undefined : _a.randomUUID) === "function" ? globalThis.crypto.randomUUID.bind(globalThis.crypto) : crypto7.randomUUID;
|
|
if (!uuidFunction)
|
|
uuidFunction = generateUUID;
|
|
exports.computeSha256Hash = computeSha256Hash;
|
|
exports.computeSha256Hmac = computeSha256Hmac;
|
|
exports.createAbortablePromise = createAbortablePromise;
|
|
exports.delay = delay;
|
|
exports.getErrorMessage = getErrorMessage;
|
|
exports.getRandomIntegerInclusive = getRandomIntegerInclusive;
|
|
exports.isDefined = isDefined;
|
|
exports.isError = isError;
|
|
exports.isNode = isNode;
|
|
exports.isObject = isObject;
|
|
exports.isObjectWithProperties = isObjectWithProperties;
|
|
exports.objectHasProperty = objectHasProperty;
|
|
exports.randomUUID = randomUUID;
|
|
});
|
|
|
|
// node_modules/@azure/logger/dist/index.js
|
|
var require_dist3 = __commonJS((exports) => {
|
|
var _interopDefaultLegacy = function(e) {
|
|
return e && typeof e === "object" && ("default" in e) ? e : { default: e };
|
|
};
|
|
var log = function(message, ...args) {
|
|
process.stderr.write(`${util__default["default"].format(message, ...args)}${os.EOL}`);
|
|
};
|
|
var enable = function(namespaces) {
|
|
enabledString = namespaces;
|
|
enabledNamespaces = [];
|
|
skippedNamespaces = [];
|
|
const wildcard = /\*/g;
|
|
const namespaceList = namespaces.split(",").map((ns) => ns.trim().replace(wildcard, ".*?"));
|
|
for (const ns of namespaceList)
|
|
if (ns.startsWith("-"))
|
|
skippedNamespaces.push(new RegExp(`^${ns.substr(1)}\$`));
|
|
else
|
|
enabledNamespaces.push(new RegExp(`^${ns}\$`));
|
|
for (const instance of debuggers)
|
|
instance.enabled = enabled(instance.namespace);
|
|
};
|
|
var enabled = function(namespace) {
|
|
if (namespace.endsWith("*"))
|
|
return true;
|
|
for (const skipped of skippedNamespaces)
|
|
if (skipped.test(namespace))
|
|
return false;
|
|
for (const enabledNamespace of enabledNamespaces)
|
|
if (enabledNamespace.test(namespace))
|
|
return true;
|
|
return false;
|
|
};
|
|
var disable = function() {
|
|
const result = enabledString || "";
|
|
enable("");
|
|
return result;
|
|
};
|
|
var createDebugger = function(namespace) {
|
|
const newDebugger = Object.assign(debug2, {
|
|
enabled: enabled(namespace),
|
|
destroy,
|
|
log: debugObj.log,
|
|
namespace,
|
|
extend
|
|
});
|
|
function debug2(...args) {
|
|
if (!newDebugger.enabled)
|
|
return;
|
|
if (args.length > 0)
|
|
args[0] = `${namespace} ${args[0]}`;
|
|
newDebugger.log(...args);
|
|
}
|
|
debuggers.push(newDebugger);
|
|
return newDebugger;
|
|
};
|
|
var destroy = function() {
|
|
const index = debuggers.indexOf(this);
|
|
if (index >= 0) {
|
|
debuggers.splice(index, 1);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
var extend = function(namespace) {
|
|
const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
|
|
newDebugger.log = this.log;
|
|
return newDebugger;
|
|
};
|
|
var setLogLevel = function(level) {
|
|
if (level && !isAzureLogLevel(level))
|
|
throw new Error(`Unknown log level '${level}'. Acceptable values: ${AZURE_LOG_LEVELS.join(",")}`);
|
|
azureLogLevel = level;
|
|
const enabledNamespaces2 = [];
|
|
for (const logger of registeredLoggers)
|
|
if (shouldEnable(logger))
|
|
enabledNamespaces2.push(logger.namespace);
|
|
debug.enable(enabledNamespaces2.join(","));
|
|
};
|
|
var getLogLevel = function() {
|
|
return azureLogLevel;
|
|
};
|
|
var createClientLogger = function(namespace) {
|
|
const clientRootLogger = AzureLogger.extend(namespace);
|
|
patchLogMethod(AzureLogger, clientRootLogger);
|
|
return {
|
|
error: createLogger(clientRootLogger, "error"),
|
|
warning: createLogger(clientRootLogger, "warning"),
|
|
info: createLogger(clientRootLogger, "info"),
|
|
verbose: createLogger(clientRootLogger, "verbose")
|
|
};
|
|
};
|
|
var patchLogMethod = function(parent, child) {
|
|
child.log = (...args) => {
|
|
parent.log(...args);
|
|
};
|
|
};
|
|
var createLogger = function(parent, level) {
|
|
const logger = Object.assign(parent.extend(level), {
|
|
level
|
|
});
|
|
patchLogMethod(parent, logger);
|
|
if (shouldEnable(logger)) {
|
|
const enabledNamespaces2 = debug.disable();
|
|
debug.enable(enabledNamespaces2 + "," + logger.namespace);
|
|
}
|
|
registeredLoggers.add(logger);
|
|
return logger;
|
|
};
|
|
var shouldEnable = function(logger) {
|
|
return Boolean(azureLogLevel && levelMap[logger.level] <= levelMap[azureLogLevel]);
|
|
};
|
|
var isAzureLogLevel = function(logLevel) {
|
|
return AZURE_LOG_LEVELS.includes(logLevel);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var os = __require("os");
|
|
var util = __require("util");
|
|
var util__default = _interopDefaultLegacy(util);
|
|
var debugEnvVariable = typeof process !== "undefined" && process.env && process.env.DEBUG || undefined;
|
|
var enabledString;
|
|
var enabledNamespaces = [];
|
|
var skippedNamespaces = [];
|
|
var debuggers = [];
|
|
if (debugEnvVariable)
|
|
enable(debugEnvVariable);
|
|
var debugObj = Object.assign((namespace) => {
|
|
return createDebugger(namespace);
|
|
}, {
|
|
enable,
|
|
enabled,
|
|
disable,
|
|
log
|
|
});
|
|
var debug = debugObj;
|
|
var registeredLoggers = new Set;
|
|
var logLevelFromEnv = typeof process !== "undefined" && process.env && process.env.AZURE_LOG_LEVEL || undefined;
|
|
var azureLogLevel;
|
|
var AzureLogger = debug("azure");
|
|
AzureLogger.log = (...args) => {
|
|
debug.log(...args);
|
|
};
|
|
var AZURE_LOG_LEVELS = ["verbose", "info", "warning", "error"];
|
|
if (logLevelFromEnv)
|
|
if (isAzureLogLevel(logLevelFromEnv))
|
|
setLogLevel(logLevelFromEnv);
|
|
else
|
|
console.error(`AZURE_LOG_LEVEL set to unknown log level '${logLevelFromEnv}'; logging is not enabled. Acceptable values: ${AZURE_LOG_LEVELS.join(", ")}.`);
|
|
var levelMap = {
|
|
verbose: 400,
|
|
info: 300,
|
|
warning: 200,
|
|
error: 100
|
|
};
|
|
exports.AzureLogger = AzureLogger;
|
|
exports.createClientLogger = createClientLogger;
|
|
exports.getLogLevel = getLogLevel;
|
|
exports.setLogLevel = setLogLevel;
|
|
});
|
|
|
|
// node_modules/@azure/core-auth/dist/index.js
|
|
var require_dist4 = __commonJS((exports) => {
|
|
var isDefined = function(thing) {
|
|
return typeof thing !== "undefined" && thing !== null;
|
|
};
|
|
var isObjectWithProperties = function(thing, properties) {
|
|
if (!isDefined(thing) || typeof thing !== "object")
|
|
return false;
|
|
for (const property of properties)
|
|
if (!objectHasProperty(thing, property))
|
|
return false;
|
|
return true;
|
|
};
|
|
var objectHasProperty = function(thing, property) {
|
|
return typeof thing === "object" && (property in thing);
|
|
};
|
|
var isNamedKeyCredential = function(credential) {
|
|
return isObjectWithProperties(credential, ["name", "key"]) && typeof credential.key === "string" && typeof credential.name === "string";
|
|
};
|
|
var isSASCredential = function(credential) {
|
|
return isObjectWithProperties(credential, ["signature"]) && typeof credential.signature === "string";
|
|
};
|
|
var isTokenCredential = function(credential) {
|
|
const castCredential = credential;
|
|
return castCredential && typeof castCredential.getToken === "function" && (castCredential.signRequest === undefined || castCredential.getToken.length > 0);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
|
class AzureKeyCredential {
|
|
constructor(key) {
|
|
if (!key)
|
|
throw new Error("key must be a non-empty string");
|
|
this._key = key;
|
|
}
|
|
get key() {
|
|
return this._key;
|
|
}
|
|
update(newKey) {
|
|
this._key = newKey;
|
|
}
|
|
}
|
|
|
|
class AzureNamedKeyCredential {
|
|
constructor(name, key) {
|
|
if (!name || !key)
|
|
throw new TypeError("name and key must be non-empty strings");
|
|
this._name = name;
|
|
this._key = key;
|
|
}
|
|
get key() {
|
|
return this._key;
|
|
}
|
|
get name() {
|
|
return this._name;
|
|
}
|
|
update(newName, newKey) {
|
|
if (!newName || !newKey)
|
|
throw new TypeError("newName and newKey must be non-empty strings");
|
|
this._name = newName;
|
|
this._key = newKey;
|
|
}
|
|
}
|
|
|
|
class AzureSASCredential {
|
|
constructor(signature) {
|
|
if (!signature)
|
|
throw new Error("shared access signature must be a non-empty string");
|
|
this._signature = signature;
|
|
}
|
|
get signature() {
|
|
return this._signature;
|
|
}
|
|
update(newSignature) {
|
|
if (!newSignature)
|
|
throw new Error("shared access signature must be a non-empty string");
|
|
this._signature = newSignature;
|
|
}
|
|
}
|
|
exports.AzureKeyCredential = AzureKeyCredential;
|
|
exports.AzureNamedKeyCredential = AzureNamedKeyCredential;
|
|
exports.AzureSASCredential = AzureSASCredential;
|
|
exports.isNamedKeyCredential = isNamedKeyCredential;
|
|
exports.isSASCredential = isSASCredential;
|
|
exports.isTokenCredential = isTokenCredential;
|
|
});
|
|
|
|
// node_modules/delayed-stream/lib/delayed_stream.js
|
|
var require_delayed_stream = __commonJS((exports, module) => {
|
|
var DelayedStream = function() {
|
|
this.source = null;
|
|
this.dataSize = 0;
|
|
this.maxDataSize = 1024 * 1024;
|
|
this.pauseStream = true;
|
|
this._maxDataSizeExceeded = false;
|
|
this._released = false;
|
|
this._bufferedEvents = [];
|
|
};
|
|
var Stream = __require("stream").Stream;
|
|
var util = __require("util");
|
|
module.exports = DelayedStream;
|
|
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));
|
|
};
|
|
});
|
|
|
|
// node_modules/combined-stream/lib/combined_stream.js
|
|
var require_combined_stream = __commonJS((exports, module) => {
|
|
var CombinedStream = function() {
|
|
this.writable = false;
|
|
this.readable = true;
|
|
this.dataSize = 0;
|
|
this.maxDataSize = 2 * 1024 * 1024;
|
|
this.pauseStreams = true;
|
|
this._released = false;
|
|
this._streams = [];
|
|
this._currentStream = null;
|
|
this._insideLoop = false;
|
|
this._pendingNext = false;
|
|
};
|
|
var util = __require("util");
|
|
var Stream = __require("stream").Stream;
|
|
var DelayedStream = require_delayed_stream();
|
|
module.exports = CombinedStream;
|
|
util.inherits(CombinedStream, Stream);
|
|
CombinedStream.create = function(options) {
|
|
var combinedStream = new this;
|
|
options = options || {};
|
|
for (var option in options)
|
|
combinedStream[option] = options[option];
|
|
return combinedStream;
|
|
};
|
|
CombinedStream.isStreamLike = function(stream) {
|
|
return typeof stream !== "function" && typeof stream !== "string" && typeof stream !== "boolean" && typeof stream !== "number" && !Buffer.isBuffer(stream);
|
|
};
|
|
CombinedStream.prototype.append = function(stream) {
|
|
var isStreamLike = CombinedStream.isStreamLike(stream);
|
|
if (isStreamLike) {
|
|
if (!(stream instanceof DelayedStream)) {
|
|
var newStream = DelayedStream.create(stream, {
|
|
maxDataSize: Infinity,
|
|
pauseStream: this.pauseStreams
|
|
});
|
|
stream.on("data", this._checkDataSize.bind(this));
|
|
stream = newStream;
|
|
}
|
|
this._handleErrors(stream);
|
|
if (this.pauseStreams)
|
|
stream.pause();
|
|
}
|
|
this._streams.push(stream);
|
|
return this;
|
|
};
|
|
CombinedStream.prototype.pipe = function(dest, options) {
|
|
Stream.prototype.pipe.call(this, dest, options);
|
|
this.resume();
|
|
return dest;
|
|
};
|
|
CombinedStream.prototype._getNext = function() {
|
|
this._currentStream = null;
|
|
if (this._insideLoop) {
|
|
this._pendingNext = true;
|
|
return;
|
|
}
|
|
this._insideLoop = true;
|
|
try {
|
|
do {
|
|
this._pendingNext = false;
|
|
this._realGetNext();
|
|
} while (this._pendingNext);
|
|
} finally {
|
|
this._insideLoop = false;
|
|
}
|
|
};
|
|
CombinedStream.prototype._realGetNext = function() {
|
|
var stream = this._streams.shift();
|
|
if (typeof stream == "undefined") {
|
|
this.end();
|
|
return;
|
|
}
|
|
if (typeof stream !== "function") {
|
|
this._pipeNext(stream);
|
|
return;
|
|
}
|
|
var getStream = stream;
|
|
getStream(function(stream2) {
|
|
var isStreamLike = CombinedStream.isStreamLike(stream2);
|
|
if (isStreamLike) {
|
|
stream2.on("data", this._checkDataSize.bind(this));
|
|
this._handleErrors(stream2);
|
|
}
|
|
this._pipeNext(stream2);
|
|
}.bind(this));
|
|
};
|
|
CombinedStream.prototype._pipeNext = function(stream) {
|
|
this._currentStream = stream;
|
|
var isStreamLike = CombinedStream.isStreamLike(stream);
|
|
if (isStreamLike) {
|
|
stream.on("end", this._getNext.bind(this));
|
|
stream.pipe(this, { end: false });
|
|
return;
|
|
}
|
|
var value = stream;
|
|
this.write(value);
|
|
this._getNext();
|
|
};
|
|
CombinedStream.prototype._handleErrors = function(stream) {
|
|
var self = this;
|
|
stream.on("error", function(err) {
|
|
self._emitError(err);
|
|
});
|
|
};
|
|
CombinedStream.prototype.write = function(data) {
|
|
this.emit("data", data);
|
|
};
|
|
CombinedStream.prototype.pause = function() {
|
|
if (!this.pauseStreams)
|
|
return;
|
|
if (this.pauseStreams && this._currentStream && typeof this._currentStream.pause == "function")
|
|
this._currentStream.pause();
|
|
this.emit("pause");
|
|
};
|
|
CombinedStream.prototype.resume = function() {
|
|
if (!this._released) {
|
|
this._released = true;
|
|
this.writable = true;
|
|
this._getNext();
|
|
}
|
|
if (this.pauseStreams && this._currentStream && typeof this._currentStream.resume == "function")
|
|
this._currentStream.resume();
|
|
this.emit("resume");
|
|
};
|
|
CombinedStream.prototype.end = function() {
|
|
this._reset();
|
|
this.emit("end");
|
|
};
|
|
CombinedStream.prototype.destroy = function() {
|
|
this._reset();
|
|
this.emit("close");
|
|
};
|
|
CombinedStream.prototype._reset = function() {
|
|
this.writable = false;
|
|
this._streams = [];
|
|
this._currentStream = null;
|
|
};
|
|
CombinedStream.prototype._checkDataSize = function() {
|
|
this._updateDataSize();
|
|
if (this.dataSize <= this.maxDataSize)
|
|
return;
|
|
var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
|
|
this._emitError(new Error(message));
|
|
};
|
|
CombinedStream.prototype._updateDataSize = function() {
|
|
this.dataSize = 0;
|
|
var self = this;
|
|
this._streams.forEach(function(stream) {
|
|
if (!stream.dataSize)
|
|
return;
|
|
self.dataSize += stream.dataSize;
|
|
});
|
|
if (this._currentStream && this._currentStream.dataSize)
|
|
this.dataSize += this._currentStream.dataSize;
|
|
};
|
|
CombinedStream.prototype._emitError = function(err) {
|
|
this._reset();
|
|
this.emit("error", err);
|
|
};
|
|
});
|
|
|
|
// node_modules/mime-db/db.json
|
|
var require_db = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
"application/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"application/3gpdash-qoe-report+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/3gpp-ims+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/3gpphal+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/3gpphalforms+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/a2l": {
|
|
source: "iana"
|
|
},
|
|
"application/ace+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/activemessage": {
|
|
source: "iana"
|
|
},
|
|
"application/activity+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-costmap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-costmapfilter+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-directory+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointcost+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointcostparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointprop+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-endpointpropparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-error+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-networkmap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-networkmapfilter+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-updatestreamcontrol+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/alto-updatestreamparams+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/aml": {
|
|
source: "iana"
|
|
},
|
|
"application/andrew-inset": {
|
|
source: "iana",
|
|
extensions: ["ez"]
|
|
},
|
|
"application/applefile": {
|
|
source: "iana"
|
|
},
|
|
"application/applixware": {
|
|
source: "apache",
|
|
extensions: ["aw"]
|
|
},
|
|
"application/at+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/atf": {
|
|
source: "iana"
|
|
},
|
|
"application/atfx": {
|
|
source: "iana"
|
|
},
|
|
"application/atom+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["atom"]
|
|
},
|
|
"application/atomcat+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["atomcat"]
|
|
},
|
|
"application/atomdeleted+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["atomdeleted"]
|
|
},
|
|
"application/atomicmail": {
|
|
source: "iana"
|
|
},
|
|
"application/atomsvc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["atomsvc"]
|
|
},
|
|
"application/atsc-dwd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["dwd"]
|
|
},
|
|
"application/atsc-dynamic-event-message": {
|
|
source: "iana"
|
|
},
|
|
"application/atsc-held+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["held"]
|
|
},
|
|
"application/atsc-rdt+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/atsc-rsat+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rsat"]
|
|
},
|
|
"application/atxml": {
|
|
source: "iana"
|
|
},
|
|
"application/auth-policy+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/bacnet-xdd+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/batch-smtp": {
|
|
source: "iana"
|
|
},
|
|
"application/bdoc": {
|
|
compressible: false,
|
|
extensions: ["bdoc"]
|
|
},
|
|
"application/beep+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/calendar+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/calendar+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xcs"]
|
|
},
|
|
"application/call-completion": {
|
|
source: "iana"
|
|
},
|
|
"application/cals-1840": {
|
|
source: "iana"
|
|
},
|
|
"application/captive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/cbor-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/cccex": {
|
|
source: "iana"
|
|
},
|
|
"application/ccmp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ccxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ccxml"]
|
|
},
|
|
"application/cdfx+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["cdfx"]
|
|
},
|
|
"application/cdmi-capability": {
|
|
source: "iana",
|
|
extensions: ["cdmia"]
|
|
},
|
|
"application/cdmi-container": {
|
|
source: "iana",
|
|
extensions: ["cdmic"]
|
|
},
|
|
"application/cdmi-domain": {
|
|
source: "iana",
|
|
extensions: ["cdmid"]
|
|
},
|
|
"application/cdmi-object": {
|
|
source: "iana",
|
|
extensions: ["cdmio"]
|
|
},
|
|
"application/cdmi-queue": {
|
|
source: "iana",
|
|
extensions: ["cdmiq"]
|
|
},
|
|
"application/cdni": {
|
|
source: "iana"
|
|
},
|
|
"application/cea": {
|
|
source: "iana"
|
|
},
|
|
"application/cea-2018+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cellml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cfw": {
|
|
source: "iana"
|
|
},
|
|
"application/city+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/clr": {
|
|
source: "iana"
|
|
},
|
|
"application/clue+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/clue_info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cms": {
|
|
source: "iana"
|
|
},
|
|
"application/cnrp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/coap-group+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/coap-payload": {
|
|
source: "iana"
|
|
},
|
|
"application/commonground": {
|
|
source: "iana"
|
|
},
|
|
"application/conference-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cose": {
|
|
source: "iana"
|
|
},
|
|
"application/cose-key": {
|
|
source: "iana"
|
|
},
|
|
"application/cose-key-set": {
|
|
source: "iana"
|
|
},
|
|
"application/cpl+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["cpl"]
|
|
},
|
|
"application/csrattrs": {
|
|
source: "iana"
|
|
},
|
|
"application/csta+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cstadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/csvm+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/cu-seeme": {
|
|
source: "apache",
|
|
extensions: ["cu"]
|
|
},
|
|
"application/cwt": {
|
|
source: "iana"
|
|
},
|
|
"application/cybercash": {
|
|
source: "iana"
|
|
},
|
|
"application/dart": {
|
|
compressible: true
|
|
},
|
|
"application/dash+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mpd"]
|
|
},
|
|
"application/dash-patch+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mpp"]
|
|
},
|
|
"application/dashdelta": {
|
|
source: "iana"
|
|
},
|
|
"application/davmount+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["davmount"]
|
|
},
|
|
"application/dca-rft": {
|
|
source: "iana"
|
|
},
|
|
"application/dcd": {
|
|
source: "iana"
|
|
},
|
|
"application/dec-dx": {
|
|
source: "iana"
|
|
},
|
|
"application/dialog-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dicom": {
|
|
source: "iana"
|
|
},
|
|
"application/dicom+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dicom+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dii": {
|
|
source: "iana"
|
|
},
|
|
"application/dit": {
|
|
source: "iana"
|
|
},
|
|
"application/dns": {
|
|
source: "iana"
|
|
},
|
|
"application/dns+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dns-message": {
|
|
source: "iana"
|
|
},
|
|
"application/docbook+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["dbk"]
|
|
},
|
|
"application/dots+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/dskpp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/dssc+der": {
|
|
source: "iana",
|
|
extensions: ["dssc"]
|
|
},
|
|
"application/dssc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xdssc"]
|
|
},
|
|
"application/dvcs": {
|
|
source: "iana"
|
|
},
|
|
"application/ecmascript": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["es", "ecma"]
|
|
},
|
|
"application/edi-consent": {
|
|
source: "iana"
|
|
},
|
|
"application/edi-x12": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/edifact": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/efi": {
|
|
source: "iana"
|
|
},
|
|
"application/elm+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/elm+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.cap+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.comment+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.deviceinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.ecall.msd": {
|
|
source: "iana"
|
|
},
|
|
"application/emergencycalldata.providerinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.serviceinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.subscriberinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emergencycalldata.veds+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/emma+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["emma"]
|
|
},
|
|
"application/emotionml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["emotionml"]
|
|
},
|
|
"application/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"application/epp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/epub+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["epub"]
|
|
},
|
|
"application/eshop": {
|
|
source: "iana"
|
|
},
|
|
"application/exi": {
|
|
source: "iana",
|
|
extensions: ["exi"]
|
|
},
|
|
"application/expect-ct-report+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/express": {
|
|
source: "iana",
|
|
extensions: ["exp"]
|
|
},
|
|
"application/fastinfoset": {
|
|
source: "iana"
|
|
},
|
|
"application/fastsoap": {
|
|
source: "iana"
|
|
},
|
|
"application/fdt+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["fdt"]
|
|
},
|
|
"application/fhir+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/fhir+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/fido.trusted-apps+json": {
|
|
compressible: true
|
|
},
|
|
"application/fits": {
|
|
source: "iana"
|
|
},
|
|
"application/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"application/font-sfnt": {
|
|
source: "iana"
|
|
},
|
|
"application/font-tdpfr": {
|
|
source: "iana",
|
|
extensions: ["pfr"]
|
|
},
|
|
"application/font-woff": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/framework-attributes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/geo+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["geojson"]
|
|
},
|
|
"application/geo+json-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/geopackage+sqlite3": {
|
|
source: "iana"
|
|
},
|
|
"application/geoxacml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/gltf-buffer": {
|
|
source: "iana"
|
|
},
|
|
"application/gml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["gml"]
|
|
},
|
|
"application/gpx+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["gpx"]
|
|
},
|
|
"application/gxf": {
|
|
source: "apache",
|
|
extensions: ["gxf"]
|
|
},
|
|
"application/gzip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["gz"]
|
|
},
|
|
"application/h224": {
|
|
source: "iana"
|
|
},
|
|
"application/held+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/hjson": {
|
|
extensions: ["hjson"]
|
|
},
|
|
"application/http": {
|
|
source: "iana"
|
|
},
|
|
"application/hyperstudio": {
|
|
source: "iana",
|
|
extensions: ["stk"]
|
|
},
|
|
"application/ibe-key-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ibe-pkg-reply+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ibe-pp-data": {
|
|
source: "iana"
|
|
},
|
|
"application/iges": {
|
|
source: "iana"
|
|
},
|
|
"application/im-iscomposing+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/index": {
|
|
source: "iana"
|
|
},
|
|
"application/index.cmd": {
|
|
source: "iana"
|
|
},
|
|
"application/index.obj": {
|
|
source: "iana"
|
|
},
|
|
"application/index.response": {
|
|
source: "iana"
|
|
},
|
|
"application/index.vnd": {
|
|
source: "iana"
|
|
},
|
|
"application/inkml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ink", "inkml"]
|
|
},
|
|
"application/iotp": {
|
|
source: "iana"
|
|
},
|
|
"application/ipfix": {
|
|
source: "iana",
|
|
extensions: ["ipfix"]
|
|
},
|
|
"application/ipp": {
|
|
source: "iana"
|
|
},
|
|
"application/isup": {
|
|
source: "iana"
|
|
},
|
|
"application/its+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["its"]
|
|
},
|
|
"application/java-archive": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["jar", "war", "ear"]
|
|
},
|
|
"application/java-serialized-object": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["ser"]
|
|
},
|
|
"application/java-vm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["class"]
|
|
},
|
|
"application/javascript": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["js", "mjs"]
|
|
},
|
|
"application/jf2feed+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jose": {
|
|
source: "iana"
|
|
},
|
|
"application/jose+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jrd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jscalendar+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["json", "map"]
|
|
},
|
|
"application/json-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/json-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/json5": {
|
|
extensions: ["json5"]
|
|
},
|
|
"application/jsonml+json": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["jsonml"]
|
|
},
|
|
"application/jwk+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jwk-set+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/kpml-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/kpml-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/ld+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["jsonld"]
|
|
},
|
|
"application/lgr+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["lgr"]
|
|
},
|
|
"application/link-format": {
|
|
source: "iana"
|
|
},
|
|
"application/load-control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/lost+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["lostxml"]
|
|
},
|
|
"application/lostsync+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/lpf+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/lxf": {
|
|
source: "iana"
|
|
},
|
|
"application/mac-binhex40": {
|
|
source: "iana",
|
|
extensions: ["hqx"]
|
|
},
|
|
"application/mac-compactpro": {
|
|
source: "apache",
|
|
extensions: ["cpt"]
|
|
},
|
|
"application/macwriteii": {
|
|
source: "iana"
|
|
},
|
|
"application/mads+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mads"]
|
|
},
|
|
"application/manifest+json": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["webmanifest"]
|
|
},
|
|
"application/marc": {
|
|
source: "iana",
|
|
extensions: ["mrc"]
|
|
},
|
|
"application/marcxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mrcx"]
|
|
},
|
|
"application/mathematica": {
|
|
source: "iana",
|
|
extensions: ["ma", "nb", "mb"]
|
|
},
|
|
"application/mathml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mathml"]
|
|
},
|
|
"application/mathml-content+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mathml-presentation+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-associated-procedure-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-deregister+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-envelope+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-msk+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-msk-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-protection-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-reception-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-register+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-register-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-schedule+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbms-user-service-description+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mbox": {
|
|
source: "iana",
|
|
extensions: ["mbox"]
|
|
},
|
|
"application/media-policy-dataset+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mpf"]
|
|
},
|
|
"application/media_control+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mediaservercontrol+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mscml"]
|
|
},
|
|
"application/merge-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/metalink+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["metalink"]
|
|
},
|
|
"application/metalink4+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["meta4"]
|
|
},
|
|
"application/mets+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mets"]
|
|
},
|
|
"application/mf4": {
|
|
source: "iana"
|
|
},
|
|
"application/mikey": {
|
|
source: "iana"
|
|
},
|
|
"application/mipc": {
|
|
source: "iana"
|
|
},
|
|
"application/missing-blocks+cbor-seq": {
|
|
source: "iana"
|
|
},
|
|
"application/mmt-aei+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["maei"]
|
|
},
|
|
"application/mmt-usd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["musd"]
|
|
},
|
|
"application/mods+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mods"]
|
|
},
|
|
"application/moss-keys": {
|
|
source: "iana"
|
|
},
|
|
"application/moss-signature": {
|
|
source: "iana"
|
|
},
|
|
"application/mosskey-data": {
|
|
source: "iana"
|
|
},
|
|
"application/mosskey-request": {
|
|
source: "iana"
|
|
},
|
|
"application/mp21": {
|
|
source: "iana",
|
|
extensions: ["m21", "mp21"]
|
|
},
|
|
"application/mp4": {
|
|
source: "iana",
|
|
extensions: ["mp4s", "m4p"]
|
|
},
|
|
"application/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"application/mpeg4-iod": {
|
|
source: "iana"
|
|
},
|
|
"application/mpeg4-iod-xmt": {
|
|
source: "iana"
|
|
},
|
|
"application/mrb-consumer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/mrb-publish+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/msc-ivr+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/msc-mixer+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/msword": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["doc", "dot"]
|
|
},
|
|
"application/mud+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/multipart-core": {
|
|
source: "iana"
|
|
},
|
|
"application/mxf": {
|
|
source: "iana",
|
|
extensions: ["mxf"]
|
|
},
|
|
"application/n-quads": {
|
|
source: "iana",
|
|
extensions: ["nq"]
|
|
},
|
|
"application/n-triples": {
|
|
source: "iana",
|
|
extensions: ["nt"]
|
|
},
|
|
"application/nasdata": {
|
|
source: "iana"
|
|
},
|
|
"application/news-checkgroups": {
|
|
source: "iana",
|
|
charset: "US-ASCII"
|
|
},
|
|
"application/news-groupinfo": {
|
|
source: "iana",
|
|
charset: "US-ASCII"
|
|
},
|
|
"application/news-transmission": {
|
|
source: "iana"
|
|
},
|
|
"application/nlsml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/node": {
|
|
source: "iana",
|
|
extensions: ["cjs"]
|
|
},
|
|
"application/nss": {
|
|
source: "iana"
|
|
},
|
|
"application/oauth-authz-req+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/oblivious-dns-message": {
|
|
source: "iana"
|
|
},
|
|
"application/ocsp-request": {
|
|
source: "iana"
|
|
},
|
|
"application/ocsp-response": {
|
|
source: "iana"
|
|
},
|
|
"application/octet-stream": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"]
|
|
},
|
|
"application/oda": {
|
|
source: "iana",
|
|
extensions: ["oda"]
|
|
},
|
|
"application/odm+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/odx": {
|
|
source: "iana"
|
|
},
|
|
"application/oebps-package+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["opf"]
|
|
},
|
|
"application/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["ogx"]
|
|
},
|
|
"application/omdoc+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["omdoc"]
|
|
},
|
|
"application/onenote": {
|
|
source: "apache",
|
|
extensions: ["onetoc", "onetoc2", "onetmp", "onepkg"]
|
|
},
|
|
"application/opc-nodeset+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/oscore": {
|
|
source: "iana"
|
|
},
|
|
"application/oxps": {
|
|
source: "iana",
|
|
extensions: ["oxps"]
|
|
},
|
|
"application/p21": {
|
|
source: "iana"
|
|
},
|
|
"application/p21+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/p2p-overlay+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["relo"]
|
|
},
|
|
"application/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"application/passport": {
|
|
source: "iana"
|
|
},
|
|
"application/patch-ops-error+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xer"]
|
|
},
|
|
"application/pdf": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["pdf"]
|
|
},
|
|
"application/pdx": {
|
|
source: "iana"
|
|
},
|
|
"application/pem-certificate-chain": {
|
|
source: "iana"
|
|
},
|
|
"application/pgp-encrypted": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["pgp"]
|
|
},
|
|
"application/pgp-keys": {
|
|
source: "iana",
|
|
extensions: ["asc"]
|
|
},
|
|
"application/pgp-signature": {
|
|
source: "iana",
|
|
extensions: ["asc", "sig"]
|
|
},
|
|
"application/pics-rules": {
|
|
source: "apache",
|
|
extensions: ["prf"]
|
|
},
|
|
"application/pidf+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/pidf-diff+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/pkcs10": {
|
|
source: "iana",
|
|
extensions: ["p10"]
|
|
},
|
|
"application/pkcs12": {
|
|
source: "iana"
|
|
},
|
|
"application/pkcs7-mime": {
|
|
source: "iana",
|
|
extensions: ["p7m", "p7c"]
|
|
},
|
|
"application/pkcs7-signature": {
|
|
source: "iana",
|
|
extensions: ["p7s"]
|
|
},
|
|
"application/pkcs8": {
|
|
source: "iana",
|
|
extensions: ["p8"]
|
|
},
|
|
"application/pkcs8-encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/pkix-attr-cert": {
|
|
source: "iana",
|
|
extensions: ["ac"]
|
|
},
|
|
"application/pkix-cert": {
|
|
source: "iana",
|
|
extensions: ["cer"]
|
|
},
|
|
"application/pkix-crl": {
|
|
source: "iana",
|
|
extensions: ["crl"]
|
|
},
|
|
"application/pkix-pkipath": {
|
|
source: "iana",
|
|
extensions: ["pkipath"]
|
|
},
|
|
"application/pkixcmp": {
|
|
source: "iana",
|
|
extensions: ["pki"]
|
|
},
|
|
"application/pls+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["pls"]
|
|
},
|
|
"application/poc-settings+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/postscript": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ai", "eps", "ps"]
|
|
},
|
|
"application/ppsp-tracker+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/problem+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/problem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/provenance+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["provx"]
|
|
},
|
|
"application/prs.alvestrand.titrax-sheet": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.cww": {
|
|
source: "iana",
|
|
extensions: ["cww"]
|
|
},
|
|
"application/prs.cyn": {
|
|
source: "iana",
|
|
charset: "7-BIT"
|
|
},
|
|
"application/prs.hpub+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/prs.nprend": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.plucker": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.rdf-xml-crypt": {
|
|
source: "iana"
|
|
},
|
|
"application/prs.xsf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/pskc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["pskcxml"]
|
|
},
|
|
"application/pvd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/qsig": {
|
|
source: "iana"
|
|
},
|
|
"application/raml+yaml": {
|
|
compressible: true,
|
|
extensions: ["raml"]
|
|
},
|
|
"application/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"application/rdap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/rdf+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rdf", "owl"]
|
|
},
|
|
"application/reginfo+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rif"]
|
|
},
|
|
"application/relax-ng-compact-syntax": {
|
|
source: "iana",
|
|
extensions: ["rnc"]
|
|
},
|
|
"application/remote-printing": {
|
|
source: "iana"
|
|
},
|
|
"application/reputon+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/resource-lists+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rl"]
|
|
},
|
|
"application/resource-lists-diff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rld"]
|
|
},
|
|
"application/rfc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/riscos": {
|
|
source: "iana"
|
|
},
|
|
"application/rlmi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/rls-services+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rs"]
|
|
},
|
|
"application/route-apd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rapd"]
|
|
},
|
|
"application/route-s-tsid+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["sls"]
|
|
},
|
|
"application/route-usd+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rusd"]
|
|
},
|
|
"application/rpki-ghostbusters": {
|
|
source: "iana",
|
|
extensions: ["gbr"]
|
|
},
|
|
"application/rpki-manifest": {
|
|
source: "iana",
|
|
extensions: ["mft"]
|
|
},
|
|
"application/rpki-publication": {
|
|
source: "iana"
|
|
},
|
|
"application/rpki-roa": {
|
|
source: "iana",
|
|
extensions: ["roa"]
|
|
},
|
|
"application/rpki-updown": {
|
|
source: "iana"
|
|
},
|
|
"application/rsd+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["rsd"]
|
|
},
|
|
"application/rss+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["rss"]
|
|
},
|
|
"application/rtf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rtf"]
|
|
},
|
|
"application/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"application/rtx": {
|
|
source: "iana"
|
|
},
|
|
"application/samlassertion+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/samlmetadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sarif+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sarif-external-properties+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sbe": {
|
|
source: "iana"
|
|
},
|
|
"application/sbml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["sbml"]
|
|
},
|
|
"application/scaip+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/scim+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/scvp-cv-request": {
|
|
source: "iana",
|
|
extensions: ["scq"]
|
|
},
|
|
"application/scvp-cv-response": {
|
|
source: "iana",
|
|
extensions: ["scs"]
|
|
},
|
|
"application/scvp-vp-request": {
|
|
source: "iana",
|
|
extensions: ["spq"]
|
|
},
|
|
"application/scvp-vp-response": {
|
|
source: "iana",
|
|
extensions: ["spp"]
|
|
},
|
|
"application/sdp": {
|
|
source: "iana",
|
|
extensions: ["sdp"]
|
|
},
|
|
"application/secevent+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/senml+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/senml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/senml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["senmlx"]
|
|
},
|
|
"application/senml-etch+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/senml-etch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/senml-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/sensml+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/sensml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sensml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["sensmlx"]
|
|
},
|
|
"application/sensml-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/sep+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sep-exi": {
|
|
source: "iana"
|
|
},
|
|
"application/session-info": {
|
|
source: "iana"
|
|
},
|
|
"application/set-payment": {
|
|
source: "iana"
|
|
},
|
|
"application/set-payment-initiation": {
|
|
source: "iana",
|
|
extensions: ["setpay"]
|
|
},
|
|
"application/set-registration": {
|
|
source: "iana"
|
|
},
|
|
"application/set-registration-initiation": {
|
|
source: "iana",
|
|
extensions: ["setreg"]
|
|
},
|
|
"application/sgml": {
|
|
source: "iana"
|
|
},
|
|
"application/sgml-open-catalog": {
|
|
source: "iana"
|
|
},
|
|
"application/shf+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["shf"]
|
|
},
|
|
"application/sieve": {
|
|
source: "iana",
|
|
extensions: ["siv", "sieve"]
|
|
},
|
|
"application/simple-filter+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/simple-message-summary": {
|
|
source: "iana"
|
|
},
|
|
"application/simplesymbolcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/sipc": {
|
|
source: "iana"
|
|
},
|
|
"application/slate": {
|
|
source: "iana"
|
|
},
|
|
"application/smil": {
|
|
source: "iana"
|
|
},
|
|
"application/smil+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["smi", "smil"]
|
|
},
|
|
"application/smpte336m": {
|
|
source: "iana"
|
|
},
|
|
"application/soap+fastinfoset": {
|
|
source: "iana"
|
|
},
|
|
"application/soap+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sparql-query": {
|
|
source: "iana",
|
|
extensions: ["rq"]
|
|
},
|
|
"application/sparql-results+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["srx"]
|
|
},
|
|
"application/spdx+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/spirits-event+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/sql": {
|
|
source: "iana"
|
|
},
|
|
"application/srgs": {
|
|
source: "iana",
|
|
extensions: ["gram"]
|
|
},
|
|
"application/srgs+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["grxml"]
|
|
},
|
|
"application/sru+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["sru"]
|
|
},
|
|
"application/ssdl+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["ssdl"]
|
|
},
|
|
"application/ssml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ssml"]
|
|
},
|
|
"application/stix+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/swid+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["swidtag"]
|
|
},
|
|
"application/tamp-apex-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-apex-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-community-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-community-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-error": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-sequence-adjust": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-sequence-adjust-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-status-query": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-status-response": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-update": {
|
|
source: "iana"
|
|
},
|
|
"application/tamp-update-confirm": {
|
|
source: "iana"
|
|
},
|
|
"application/tar": {
|
|
compressible: true
|
|
},
|
|
"application/taxii+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/td+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/tei+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["tei", "teicorpus"]
|
|
},
|
|
"application/tetra_isi": {
|
|
source: "iana"
|
|
},
|
|
"application/thraud+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["tfi"]
|
|
},
|
|
"application/timestamp-query": {
|
|
source: "iana"
|
|
},
|
|
"application/timestamp-reply": {
|
|
source: "iana"
|
|
},
|
|
"application/timestamped-data": {
|
|
source: "iana",
|
|
extensions: ["tsd"]
|
|
},
|
|
"application/tlsrpt+gzip": {
|
|
source: "iana"
|
|
},
|
|
"application/tlsrpt+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/tnauthlist": {
|
|
source: "iana"
|
|
},
|
|
"application/token-introspection+jwt": {
|
|
source: "iana"
|
|
},
|
|
"application/toml": {
|
|
compressible: true,
|
|
extensions: ["toml"]
|
|
},
|
|
"application/trickle-ice-sdpfrag": {
|
|
source: "iana"
|
|
},
|
|
"application/trig": {
|
|
source: "iana",
|
|
extensions: ["trig"]
|
|
},
|
|
"application/ttml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ttml"]
|
|
},
|
|
"application/tve-trigger": {
|
|
source: "iana"
|
|
},
|
|
"application/tzif": {
|
|
source: "iana"
|
|
},
|
|
"application/tzif-leap": {
|
|
source: "iana"
|
|
},
|
|
"application/ubjson": {
|
|
compressible: false,
|
|
extensions: ["ubj"]
|
|
},
|
|
"application/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"application/urc-grpsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/urc-ressheet+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rsheet"]
|
|
},
|
|
"application/urc-targetdesc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["td"]
|
|
},
|
|
"application/urc-uisocketdesc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vcard+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vcard+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vemmi": {
|
|
source: "iana"
|
|
},
|
|
"application/vividence.scriptfile": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.1000minds.decision-model+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["1km"]
|
|
},
|
|
"application/vnd.3gpp-prose+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp-prose-pc3ch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp-v2x-local-service-information": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.5gnas": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.access-transfer-events+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.bsf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.gmop+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.gtpc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.interworking-data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.lpp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mc-signalling-ear": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-payload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-signalling": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.mcdata-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcdata-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-floor-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-location-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-signed+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-ue-init-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcptt-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-command+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-affiliation-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-location-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-service-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-transmission-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-ue-config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mcvideo-user-profile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.mid-call+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.ngap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.pfcp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.pic-bw-large": {
|
|
source: "iana",
|
|
extensions: ["plb"]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-small": {
|
|
source: "iana",
|
|
extensions: ["psb"]
|
|
},
|
|
"application/vnd.3gpp.pic-bw-var": {
|
|
source: "iana",
|
|
extensions: ["pvb"]
|
|
},
|
|
"application/vnd.3gpp.s1ap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp.sms+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.srvcc-ext+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.srvcc-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.state-and-event-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp.ussd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp2.bcmcsinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.3gpp2.sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3gpp2.tcap": {
|
|
source: "iana",
|
|
extensions: ["tcap"]
|
|
},
|
|
"application/vnd.3lightssoftware.imagescal": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.3m.post-it-notes": {
|
|
source: "iana",
|
|
extensions: ["pwn"]
|
|
},
|
|
"application/vnd.accpac.simply.aso": {
|
|
source: "iana",
|
|
extensions: ["aso"]
|
|
},
|
|
"application/vnd.accpac.simply.imp": {
|
|
source: "iana",
|
|
extensions: ["imp"]
|
|
},
|
|
"application/vnd.acucobol": {
|
|
source: "iana",
|
|
extensions: ["acu"]
|
|
},
|
|
"application/vnd.acucorp": {
|
|
source: "iana",
|
|
extensions: ["atc", "acutc"]
|
|
},
|
|
"application/vnd.adobe.air-application-installer-package+zip": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["air"]
|
|
},
|
|
"application/vnd.adobe.flash.movie": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.adobe.formscentral.fcdt": {
|
|
source: "iana",
|
|
extensions: ["fcdt"]
|
|
},
|
|
"application/vnd.adobe.fxp": {
|
|
source: "iana",
|
|
extensions: ["fxp", "fxpl"]
|
|
},
|
|
"application/vnd.adobe.partial-upload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.adobe.xdp+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xdp"]
|
|
},
|
|
"application/vnd.adobe.xfdf": {
|
|
source: "iana",
|
|
extensions: ["xfdf"]
|
|
},
|
|
"application/vnd.aether.imp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.afplinedata-pagedef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.cmoca-cmresource": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-charset": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codedfont": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.foca-codepage": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-cmtable": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-formdef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-mediummap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-objectcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-overlay": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.afpc.modca-pagesegment": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.age": {
|
|
source: "iana",
|
|
extensions: ["age"]
|
|
},
|
|
"application/vnd.ah-barcode": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ahead.space": {
|
|
source: "iana",
|
|
extensions: ["ahead"]
|
|
},
|
|
"application/vnd.airzip.filesecure.azf": {
|
|
source: "iana",
|
|
extensions: ["azf"]
|
|
},
|
|
"application/vnd.airzip.filesecure.azs": {
|
|
source: "iana",
|
|
extensions: ["azs"]
|
|
},
|
|
"application/vnd.amadeus+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.amazon.ebook": {
|
|
source: "apache",
|
|
extensions: ["azw"]
|
|
},
|
|
"application/vnd.amazon.mobi8-ebook": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.americandynamics.acc": {
|
|
source: "iana",
|
|
extensions: ["acc"]
|
|
},
|
|
"application/vnd.amiga.ami": {
|
|
source: "iana",
|
|
extensions: ["ami"]
|
|
},
|
|
"application/vnd.amundsen.maze+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.android.ota": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.android.package-archive": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["apk"]
|
|
},
|
|
"application/vnd.anki": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.anser-web-certificate-issue-initiation": {
|
|
source: "iana",
|
|
extensions: ["cii"]
|
|
},
|
|
"application/vnd.anser-web-funds-transfer-initiation": {
|
|
source: "apache",
|
|
extensions: ["fti"]
|
|
},
|
|
"application/vnd.antix.game-component": {
|
|
source: "iana",
|
|
extensions: ["atx"]
|
|
},
|
|
"application/vnd.apache.arrow.file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.arrow.stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.binary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.compact": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.apache.thrift.json": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.api+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.aplextor.warrp+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.apothekende.reservation+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.apple.installer+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mpkg"]
|
|
},
|
|
"application/vnd.apple.keynote": {
|
|
source: "iana",
|
|
extensions: ["key"]
|
|
},
|
|
"application/vnd.apple.mpegurl": {
|
|
source: "iana",
|
|
extensions: ["m3u8"]
|
|
},
|
|
"application/vnd.apple.numbers": {
|
|
source: "iana",
|
|
extensions: ["numbers"]
|
|
},
|
|
"application/vnd.apple.pages": {
|
|
source: "iana",
|
|
extensions: ["pages"]
|
|
},
|
|
"application/vnd.apple.pkpass": {
|
|
compressible: false,
|
|
extensions: ["pkpass"]
|
|
},
|
|
"application/vnd.arastra.swi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.aristanetworks.swi": {
|
|
source: "iana",
|
|
extensions: ["swi"]
|
|
},
|
|
"application/vnd.artisan+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.artsquare": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.astraea-software.iota": {
|
|
source: "iana",
|
|
extensions: ["iota"]
|
|
},
|
|
"application/vnd.audiograph": {
|
|
source: "iana",
|
|
extensions: ["aep"]
|
|
},
|
|
"application/vnd.autopackage": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.avalon+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.avistar+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.balsamiq.bmml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["bmml"]
|
|
},
|
|
"application/vnd.balsamiq.bmpr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.banana-accounting": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.error": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bbf.usp.msg+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.bekitzur-stech+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.bint.med-content": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.biopax.rdf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.blink-idb-value-wrapper": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.blueice.multipass": {
|
|
source: "iana",
|
|
extensions: ["mpm"]
|
|
},
|
|
"application/vnd.bluetooth.ep.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bluetooth.le.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bmi": {
|
|
source: "iana",
|
|
extensions: ["bmi"]
|
|
},
|
|
"application/vnd.bpf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.bpf3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.businessobjects": {
|
|
source: "iana",
|
|
extensions: ["rep"]
|
|
},
|
|
"application/vnd.byu.uapi+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cab-jscript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.canon-cpdl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.canon-lips": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.capasystems-pg+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cendio.thinlinc.clientconf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.century-systems.tcp_stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.chemdraw+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["cdxml"]
|
|
},
|
|
"application/vnd.chess-pgn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.chipnuts.karaoke-mmd": {
|
|
source: "iana",
|
|
extensions: ["mmd"]
|
|
},
|
|
"application/vnd.ciedi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cinderella": {
|
|
source: "iana",
|
|
extensions: ["cdy"]
|
|
},
|
|
"application/vnd.cirpack.isdn-ext": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.citationstyles.style+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["csl"]
|
|
},
|
|
"application/vnd.claymore": {
|
|
source: "iana",
|
|
extensions: ["cla"]
|
|
},
|
|
"application/vnd.cloanto.rp9": {
|
|
source: "iana",
|
|
extensions: ["rp9"]
|
|
},
|
|
"application/vnd.clonk.c4group": {
|
|
source: "iana",
|
|
extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config": {
|
|
source: "iana",
|
|
extensions: ["c11amc"]
|
|
},
|
|
"application/vnd.cluetrust.cartomobile-config-pkg": {
|
|
source: "iana",
|
|
extensions: ["c11amz"]
|
|
},
|
|
"application/vnd.coffeescript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.document-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.presentation-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collabio.xodocuments.spreadsheet-template": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.collection+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.collection.doc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.collection.next+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.comicbook+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.comicbook-rar": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.commerce-battelle": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.commonspace": {
|
|
source: "iana",
|
|
extensions: ["csp"]
|
|
},
|
|
"application/vnd.contact.cmsg": {
|
|
source: "iana",
|
|
extensions: ["cdbcmsg"]
|
|
},
|
|
"application/vnd.coreos.ignition+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cosmocaller": {
|
|
source: "iana",
|
|
extensions: ["cmc"]
|
|
},
|
|
"application/vnd.crick.clicker": {
|
|
source: "iana",
|
|
extensions: ["clkx"]
|
|
},
|
|
"application/vnd.crick.clicker.keyboard": {
|
|
source: "iana",
|
|
extensions: ["clkk"]
|
|
},
|
|
"application/vnd.crick.clicker.palette": {
|
|
source: "iana",
|
|
extensions: ["clkp"]
|
|
},
|
|
"application/vnd.crick.clicker.template": {
|
|
source: "iana",
|
|
extensions: ["clkt"]
|
|
},
|
|
"application/vnd.crick.clicker.wordbank": {
|
|
source: "iana",
|
|
extensions: ["clkw"]
|
|
},
|
|
"application/vnd.criticaltools.wbs+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wbs"]
|
|
},
|
|
"application/vnd.cryptii.pipe+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.crypto-shade-file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cryptomator.encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cryptomator.vault": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ctc-posml": {
|
|
source: "iana",
|
|
extensions: ["pml"]
|
|
},
|
|
"application/vnd.ctct.ws+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cups-pdf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-postscript": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-ppd": {
|
|
source: "iana",
|
|
extensions: ["ppd"]
|
|
},
|
|
"application/vnd.cups-raster": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cups-raw": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.curl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.curl.car": {
|
|
source: "apache",
|
|
extensions: ["car"]
|
|
},
|
|
"application/vnd.curl.pcurl": {
|
|
source: "apache",
|
|
extensions: ["pcurl"]
|
|
},
|
|
"application/vnd.cyan.dean.root+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cybank": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.cyclonedx+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.cyclonedx+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.d2l.coursepackage1p0+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.d3m-dataset": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.d3m-problem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dart": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["dart"]
|
|
},
|
|
"application/vnd.data-vision.rdz": {
|
|
source: "iana",
|
|
extensions: ["rdz"]
|
|
},
|
|
"application/vnd.datapackage+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dataresource+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dbf": {
|
|
source: "iana",
|
|
extensions: ["dbf"]
|
|
},
|
|
"application/vnd.debian.binary-package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dece.data": {
|
|
source: "iana",
|
|
extensions: ["uvf", "uvvf", "uvd", "uvvd"]
|
|
},
|
|
"application/vnd.dece.ttml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["uvt", "uvvt"]
|
|
},
|
|
"application/vnd.dece.unspecified": {
|
|
source: "iana",
|
|
extensions: ["uvx", "uvvx"]
|
|
},
|
|
"application/vnd.dece.zip": {
|
|
source: "iana",
|
|
extensions: ["uvz", "uvvz"]
|
|
},
|
|
"application/vnd.denovo.fcselayout-link": {
|
|
source: "iana",
|
|
extensions: ["fe_launch"]
|
|
},
|
|
"application/vnd.desmume.movie": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dir-bi.plate-dl-nosuffix": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dm.delegation+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dna": {
|
|
source: "iana",
|
|
extensions: ["dna"]
|
|
},
|
|
"application/vnd.document+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dolby.mlp": {
|
|
source: "apache",
|
|
extensions: ["mlp"]
|
|
},
|
|
"application/vnd.dolby.mobile.1": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dolby.mobile.2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.doremir.scorecloud-binary-document": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dpgraph": {
|
|
source: "iana",
|
|
extensions: ["dpg"]
|
|
},
|
|
"application/vnd.dreamfactory": {
|
|
source: "iana",
|
|
extensions: ["dfac"]
|
|
},
|
|
"application/vnd.drive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ds-keypoint": {
|
|
source: "apache",
|
|
extensions: ["kpxx"]
|
|
},
|
|
"application/vnd.dtg.local": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dtg.local.flash": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dtg.local.html": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ait": {
|
|
source: "iana",
|
|
extensions: ["ait"]
|
|
},
|
|
"application/vnd.dvb.dvbisl+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.dvbj": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.esgcontainer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcdftnotifaccess": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgaccess2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcesgpdd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.ipdcroaming": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-base": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.iptv.alfec-enhancement": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.notif-aggregate-root+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-container+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-generic+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-msglist+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-ia-registration-response+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.notif-init+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.dvb.pfr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dvb.service": {
|
|
source: "iana",
|
|
extensions: ["svc"]
|
|
},
|
|
"application/vnd.dxr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.dynageo": {
|
|
source: "iana",
|
|
extensions: ["geo"]
|
|
},
|
|
"application/vnd.dzr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.easykaraoke.cdgdownload": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecdis-update": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecip.rlp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.eclipse.ditto+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ecowin.chart": {
|
|
source: "iana",
|
|
extensions: ["mag"]
|
|
},
|
|
"application/vnd.ecowin.filerequest": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.fileupdate": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.series": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesrequest": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ecowin.seriesupdate": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.efi.img": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.efi.iso": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.emclient.accessrequest+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.enliven": {
|
|
source: "iana",
|
|
extensions: ["nml"]
|
|
},
|
|
"application/vnd.enphase.envoy": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.eprints.data+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.epson.esf": {
|
|
source: "iana",
|
|
extensions: ["esf"]
|
|
},
|
|
"application/vnd.epson.msf": {
|
|
source: "iana",
|
|
extensions: ["msf"]
|
|
},
|
|
"application/vnd.epson.quickanime": {
|
|
source: "iana",
|
|
extensions: ["qam"]
|
|
},
|
|
"application/vnd.epson.salt": {
|
|
source: "iana",
|
|
extensions: ["slt"]
|
|
},
|
|
"application/vnd.epson.ssf": {
|
|
source: "iana",
|
|
extensions: ["ssf"]
|
|
},
|
|
"application/vnd.ericsson.quickcall": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.espass-espass+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.eszigno3+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["es3", "et3"]
|
|
},
|
|
"application/vnd.etsi.aoc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.asic-e+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.etsi.asic-s+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.etsi.cug+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvcommand+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvdiscovery+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-bc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-cod+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsad-npvr+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvservice+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvsync+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.iptvueprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.mcid+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.mheg5": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.etsi.overload-control-policy-dataset+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.pstn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.sci+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.simservs+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.timestamp-token": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.etsi.tsl+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.etsi.tsl.der": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.eu.kasparian.car+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.eudora.data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.profile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.settings": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.evolv.ecig.theme": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.exstream-empower+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.exstream-package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ezpix-album": {
|
|
source: "iana",
|
|
extensions: ["ez2"]
|
|
},
|
|
"application/vnd.ezpix-package": {
|
|
source: "iana",
|
|
extensions: ["ez3"]
|
|
},
|
|
"application/vnd.f-secure.mobile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.familysearch.gedcom+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.fastcopy-disk-image": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fdf": {
|
|
source: "iana",
|
|
extensions: ["fdf"]
|
|
},
|
|
"application/vnd.fdsn.mseed": {
|
|
source: "iana",
|
|
extensions: ["mseed"]
|
|
},
|
|
"application/vnd.fdsn.seed": {
|
|
source: "iana",
|
|
extensions: ["seed", "dataless"]
|
|
},
|
|
"application/vnd.ffsns": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ficlab.flb+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.filmit.zfc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fints": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.firemonkeys.cloudcell": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.flographit": {
|
|
source: "iana",
|
|
extensions: ["gph"]
|
|
},
|
|
"application/vnd.fluxtime.clip": {
|
|
source: "iana",
|
|
extensions: ["ftc"]
|
|
},
|
|
"application/vnd.font-fontforge-sfd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.framemaker": {
|
|
source: "iana",
|
|
extensions: ["fm", "frame", "maker", "book"]
|
|
},
|
|
"application/vnd.frogans.fnc": {
|
|
source: "iana",
|
|
extensions: ["fnc"]
|
|
},
|
|
"application/vnd.frogans.ltf": {
|
|
source: "iana",
|
|
extensions: ["ltf"]
|
|
},
|
|
"application/vnd.fsc.weblaunch": {
|
|
source: "iana",
|
|
extensions: ["fsc"]
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks.binder": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.docuworks.container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujifilm.fb.jfi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.fujitsu.oasys": {
|
|
source: "iana",
|
|
extensions: ["oas"]
|
|
},
|
|
"application/vnd.fujitsu.oasys2": {
|
|
source: "iana",
|
|
extensions: ["oa2"]
|
|
},
|
|
"application/vnd.fujitsu.oasys3": {
|
|
source: "iana",
|
|
extensions: ["oa3"]
|
|
},
|
|
"application/vnd.fujitsu.oasysgp": {
|
|
source: "iana",
|
|
extensions: ["fg5"]
|
|
},
|
|
"application/vnd.fujitsu.oasysprs": {
|
|
source: "iana",
|
|
extensions: ["bh2"]
|
|
},
|
|
"application/vnd.fujixerox.art-ex": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.art4": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.ddd": {
|
|
source: "iana",
|
|
extensions: ["ddd"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks": {
|
|
source: "iana",
|
|
extensions: ["xdw"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.binder": {
|
|
source: "iana",
|
|
extensions: ["xbd"]
|
|
},
|
|
"application/vnd.fujixerox.docuworks.container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fujixerox.hbpl": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.fut-misnet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.futoin+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.futoin+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.fuzzysheet": {
|
|
source: "iana",
|
|
extensions: ["fzs"]
|
|
},
|
|
"application/vnd.genomatix.tuxedo": {
|
|
source: "iana",
|
|
extensions: ["txd"]
|
|
},
|
|
"application/vnd.gentics.grd+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geo+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geocube+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.geogebra.file": {
|
|
source: "iana",
|
|
extensions: ["ggb"]
|
|
},
|
|
"application/vnd.geogebra.slides": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.geogebra.tool": {
|
|
source: "iana",
|
|
extensions: ["ggt"]
|
|
},
|
|
"application/vnd.geometry-explorer": {
|
|
source: "iana",
|
|
extensions: ["gex", "gre"]
|
|
},
|
|
"application/vnd.geonext": {
|
|
source: "iana",
|
|
extensions: ["gxt"]
|
|
},
|
|
"application/vnd.geoplan": {
|
|
source: "iana",
|
|
extensions: ["g2w"]
|
|
},
|
|
"application/vnd.geospace": {
|
|
source: "iana",
|
|
extensions: ["g3w"]
|
|
},
|
|
"application/vnd.gerber": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.globalplatform.card-content-mgt-response": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.gmx": {
|
|
source: "iana",
|
|
extensions: ["gmx"]
|
|
},
|
|
"application/vnd.google-apps.document": {
|
|
compressible: false,
|
|
extensions: ["gdoc"]
|
|
},
|
|
"application/vnd.google-apps.presentation": {
|
|
compressible: false,
|
|
extensions: ["gslides"]
|
|
},
|
|
"application/vnd.google-apps.spreadsheet": {
|
|
compressible: false,
|
|
extensions: ["gsheet"]
|
|
},
|
|
"application/vnd.google-earth.kml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["kml"]
|
|
},
|
|
"application/vnd.google-earth.kmz": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["kmz"]
|
|
},
|
|
"application/vnd.gov.sk.e-form+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.gov.sk.e-form+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.gov.sk.xmldatacontainer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.grafeq": {
|
|
source: "iana",
|
|
extensions: ["gqf", "gqs"]
|
|
},
|
|
"application/vnd.gridmp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.groove-account": {
|
|
source: "iana",
|
|
extensions: ["gac"]
|
|
},
|
|
"application/vnd.groove-help": {
|
|
source: "iana",
|
|
extensions: ["ghf"]
|
|
},
|
|
"application/vnd.groove-identity-message": {
|
|
source: "iana",
|
|
extensions: ["gim"]
|
|
},
|
|
"application/vnd.groove-injector": {
|
|
source: "iana",
|
|
extensions: ["grv"]
|
|
},
|
|
"application/vnd.groove-tool-message": {
|
|
source: "iana",
|
|
extensions: ["gtm"]
|
|
},
|
|
"application/vnd.groove-tool-template": {
|
|
source: "iana",
|
|
extensions: ["tpl"]
|
|
},
|
|
"application/vnd.groove-vcard": {
|
|
source: "iana",
|
|
extensions: ["vcg"]
|
|
},
|
|
"application/vnd.hal+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hal+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["hal"]
|
|
},
|
|
"application/vnd.handheld-entertainment+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["zmm"]
|
|
},
|
|
"application/vnd.hbci": {
|
|
source: "iana",
|
|
extensions: ["hbci"]
|
|
},
|
|
"application/vnd.hc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hcl-bireports": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.hdt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.heroku+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hhe.lesson-player": {
|
|
source: "iana",
|
|
extensions: ["les"]
|
|
},
|
|
"application/vnd.hl7cda+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hl7v2+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hp-hpgl": {
|
|
source: "iana",
|
|
extensions: ["hpgl"]
|
|
},
|
|
"application/vnd.hp-hpid": {
|
|
source: "iana",
|
|
extensions: ["hpid"]
|
|
},
|
|
"application/vnd.hp-hps": {
|
|
source: "iana",
|
|
extensions: ["hps"]
|
|
},
|
|
"application/vnd.hp-jlyt": {
|
|
source: "iana",
|
|
extensions: ["jlt"]
|
|
},
|
|
"application/vnd.hp-pcl": {
|
|
source: "iana",
|
|
extensions: ["pcl"]
|
|
},
|
|
"application/vnd.hp-pclxl": {
|
|
source: "iana",
|
|
extensions: ["pclxl"]
|
|
},
|
|
"application/vnd.httphone": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.hydrostatix.sof-data": {
|
|
source: "iana",
|
|
extensions: ["sfd-hdstx"]
|
|
},
|
|
"application/vnd.hyper+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hyper-item+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hyperdrive+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.hzn-3d-crossword": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.afplinedata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.electronic-media": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ibm.minipay": {
|
|
source: "iana",
|
|
extensions: ["mpy"]
|
|
},
|
|
"application/vnd.ibm.modcap": {
|
|
source: "iana",
|
|
extensions: ["afp", "listafp", "list3820"]
|
|
},
|
|
"application/vnd.ibm.rights-management": {
|
|
source: "iana",
|
|
extensions: ["irm"]
|
|
},
|
|
"application/vnd.ibm.secure-container": {
|
|
source: "iana",
|
|
extensions: ["sc"]
|
|
},
|
|
"application/vnd.iccprofile": {
|
|
source: "iana",
|
|
extensions: ["icc", "icm"]
|
|
},
|
|
"application/vnd.ieee.1905": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.igloader": {
|
|
source: "iana",
|
|
extensions: ["igl"]
|
|
},
|
|
"application/vnd.imagemeter.folder+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.imagemeter.image+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.immervision-ivp": {
|
|
source: "iana",
|
|
extensions: ["ivp"]
|
|
},
|
|
"application/vnd.immervision-ivu": {
|
|
source: "iana",
|
|
extensions: ["ivu"]
|
|
},
|
|
"application/vnd.ims.imsccv1p1": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.imsccv1p3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ims.lis.v2.result+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolconsumerprofile+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolproxy.id+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ims.lti.v2.toolsettings.simple+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.informedcontrol.rms+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.informix-visionary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.infotech.project": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.infotech.project+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.innopath.wamp.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.insors.igm": {
|
|
source: "iana",
|
|
extensions: ["igm"]
|
|
},
|
|
"application/vnd.intercon.formnet": {
|
|
source: "iana",
|
|
extensions: ["xpw", "xpx"]
|
|
},
|
|
"application/vnd.intergeo": {
|
|
source: "iana",
|
|
extensions: ["i2g"]
|
|
},
|
|
"application/vnd.intertrust.digibox": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.intertrust.nncp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.intu.qbo": {
|
|
source: "iana",
|
|
extensions: ["qbo"]
|
|
},
|
|
"application/vnd.intu.qfx": {
|
|
source: "iana",
|
|
extensions: ["qfx"]
|
|
},
|
|
"application/vnd.iptc.g2.catalogitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.conceptitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.knowledgeitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.newsitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.newsmessage+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.packageitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.iptc.g2.planningitem+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ipunplugged.rcprofile": {
|
|
source: "iana",
|
|
extensions: ["rcprofile"]
|
|
},
|
|
"application/vnd.irepository.package+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["irp"]
|
|
},
|
|
"application/vnd.is-xpr": {
|
|
source: "iana",
|
|
extensions: ["xpr"]
|
|
},
|
|
"application/vnd.isac.fcs": {
|
|
source: "iana",
|
|
extensions: ["fcs"]
|
|
},
|
|
"application/vnd.iso11783-10+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.jam": {
|
|
source: "iana",
|
|
extensions: ["jam"]
|
|
},
|
|
"application/vnd.japannet-directory-service": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-jpnstore-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-payment-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-registration": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-registration-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-setstore-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-verification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.japannet-verification-wakeup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.jcp.javame.midlet-rms": {
|
|
source: "iana",
|
|
extensions: ["rms"]
|
|
},
|
|
"application/vnd.jisp": {
|
|
source: "iana",
|
|
extensions: ["jisp"]
|
|
},
|
|
"application/vnd.joost.joda-archive": {
|
|
source: "iana",
|
|
extensions: ["joda"]
|
|
},
|
|
"application/vnd.jsk.isdn-ngn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.kahootz": {
|
|
source: "iana",
|
|
extensions: ["ktz", "ktr"]
|
|
},
|
|
"application/vnd.kde.karbon": {
|
|
source: "iana",
|
|
extensions: ["karbon"]
|
|
},
|
|
"application/vnd.kde.kchart": {
|
|
source: "iana",
|
|
extensions: ["chrt"]
|
|
},
|
|
"application/vnd.kde.kformula": {
|
|
source: "iana",
|
|
extensions: ["kfo"]
|
|
},
|
|
"application/vnd.kde.kivio": {
|
|
source: "iana",
|
|
extensions: ["flw"]
|
|
},
|
|
"application/vnd.kde.kontour": {
|
|
source: "iana",
|
|
extensions: ["kon"]
|
|
},
|
|
"application/vnd.kde.kpresenter": {
|
|
source: "iana",
|
|
extensions: ["kpr", "kpt"]
|
|
},
|
|
"application/vnd.kde.kspread": {
|
|
source: "iana",
|
|
extensions: ["ksp"]
|
|
},
|
|
"application/vnd.kde.kword": {
|
|
source: "iana",
|
|
extensions: ["kwd", "kwt"]
|
|
},
|
|
"application/vnd.kenameaapp": {
|
|
source: "iana",
|
|
extensions: ["htke"]
|
|
},
|
|
"application/vnd.kidspiration": {
|
|
source: "iana",
|
|
extensions: ["kia"]
|
|
},
|
|
"application/vnd.kinar": {
|
|
source: "iana",
|
|
extensions: ["kne", "knp"]
|
|
},
|
|
"application/vnd.koan": {
|
|
source: "iana",
|
|
extensions: ["skp", "skd", "skt", "skm"]
|
|
},
|
|
"application/vnd.kodak-descriptor": {
|
|
source: "iana",
|
|
extensions: ["sse"]
|
|
},
|
|
"application/vnd.las": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.las.las+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.las.las+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["lasxml"]
|
|
},
|
|
"application/vnd.laszip": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.leap+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.liberty-request+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.desktop": {
|
|
source: "iana",
|
|
extensions: ["lbd"]
|
|
},
|
|
"application/vnd.llamagraphics.life-balance.exchange+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["lbe"]
|
|
},
|
|
"application/vnd.logipipe.circuit+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.loom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.lotus-1-2-3": {
|
|
source: "iana",
|
|
extensions: ["123"]
|
|
},
|
|
"application/vnd.lotus-approach": {
|
|
source: "iana",
|
|
extensions: ["apr"]
|
|
},
|
|
"application/vnd.lotus-freelance": {
|
|
source: "iana",
|
|
extensions: ["pre"]
|
|
},
|
|
"application/vnd.lotus-notes": {
|
|
source: "iana",
|
|
extensions: ["nsf"]
|
|
},
|
|
"application/vnd.lotus-organizer": {
|
|
source: "iana",
|
|
extensions: ["org"]
|
|
},
|
|
"application/vnd.lotus-screencam": {
|
|
source: "iana",
|
|
extensions: ["scm"]
|
|
},
|
|
"application/vnd.lotus-wordpro": {
|
|
source: "iana",
|
|
extensions: ["lwp"]
|
|
},
|
|
"application/vnd.macports.portpkg": {
|
|
source: "iana",
|
|
extensions: ["portpkg"]
|
|
},
|
|
"application/vnd.mapbox-vector-tile": {
|
|
source: "iana",
|
|
extensions: ["mvt"]
|
|
},
|
|
"application/vnd.marlin.drm.actiontoken+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.conftoken+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.license+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.marlin.drm.mdcf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mason+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.maxar.archive.3tz+zip": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"application/vnd.maxmind.maxmind-db": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mcd": {
|
|
source: "iana",
|
|
extensions: ["mcd"]
|
|
},
|
|
"application/vnd.medcalcdata": {
|
|
source: "iana",
|
|
extensions: ["mc1"]
|
|
},
|
|
"application/vnd.mediastation.cdkey": {
|
|
source: "iana",
|
|
extensions: ["cdkey"]
|
|
},
|
|
"application/vnd.meridian-slingshot": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mfer": {
|
|
source: "iana",
|
|
extensions: ["mwf"]
|
|
},
|
|
"application/vnd.mfmp": {
|
|
source: "iana",
|
|
extensions: ["mfm"]
|
|
},
|
|
"application/vnd.micro+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.micrografx.flo": {
|
|
source: "iana",
|
|
extensions: ["flo"]
|
|
},
|
|
"application/vnd.micrografx.igx": {
|
|
source: "iana",
|
|
extensions: ["igx"]
|
|
},
|
|
"application/vnd.microsoft.portable-executable": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.microsoft.windows.thumbnail-cache": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.miele+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.mif": {
|
|
source: "iana",
|
|
extensions: ["mif"]
|
|
},
|
|
"application/vnd.minisoft-hp3000-save": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mitsubishi.misty-guard.trustweb": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mobius.daf": {
|
|
source: "iana",
|
|
extensions: ["daf"]
|
|
},
|
|
"application/vnd.mobius.dis": {
|
|
source: "iana",
|
|
extensions: ["dis"]
|
|
},
|
|
"application/vnd.mobius.mbk": {
|
|
source: "iana",
|
|
extensions: ["mbk"]
|
|
},
|
|
"application/vnd.mobius.mqy": {
|
|
source: "iana",
|
|
extensions: ["mqy"]
|
|
},
|
|
"application/vnd.mobius.msl": {
|
|
source: "iana",
|
|
extensions: ["msl"]
|
|
},
|
|
"application/vnd.mobius.plc": {
|
|
source: "iana",
|
|
extensions: ["plc"]
|
|
},
|
|
"application/vnd.mobius.txf": {
|
|
source: "iana",
|
|
extensions: ["txf"]
|
|
},
|
|
"application/vnd.mophun.application": {
|
|
source: "iana",
|
|
extensions: ["mpn"]
|
|
},
|
|
"application/vnd.mophun.certificate": {
|
|
source: "iana",
|
|
extensions: ["mpc"]
|
|
},
|
|
"application/vnd.motorola.flexsuite": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.adsi": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.fis": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.gotap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.kmr": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.ttc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.flexsuite.wem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.motorola.iprm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mozilla.xul+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xul"]
|
|
},
|
|
"application/vnd.ms-3mfdocument": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-artgalry": {
|
|
source: "iana",
|
|
extensions: ["cil"]
|
|
},
|
|
"application/vnd.ms-asf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-cab-compressed": {
|
|
source: "iana",
|
|
extensions: ["cab"]
|
|
},
|
|
"application/vnd.ms-color.iccprofile": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.ms-excel": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"]
|
|
},
|
|
"application/vnd.ms-excel.addin.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["xlam"]
|
|
},
|
|
"application/vnd.ms-excel.sheet.binary.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["xlsb"]
|
|
},
|
|
"application/vnd.ms-excel.sheet.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["xlsm"]
|
|
},
|
|
"application/vnd.ms-excel.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["xltm"]
|
|
},
|
|
"application/vnd.ms-fontobject": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["eot"]
|
|
},
|
|
"application/vnd.ms-htmlhelp": {
|
|
source: "iana",
|
|
extensions: ["chm"]
|
|
},
|
|
"application/vnd.ms-ims": {
|
|
source: "iana",
|
|
extensions: ["ims"]
|
|
},
|
|
"application/vnd.ms-lrm": {
|
|
source: "iana",
|
|
extensions: ["lrm"]
|
|
},
|
|
"application/vnd.ms-office.activex+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-officetheme": {
|
|
source: "iana",
|
|
extensions: ["thmx"]
|
|
},
|
|
"application/vnd.ms-opentype": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-outlook": {
|
|
compressible: false,
|
|
extensions: ["msg"]
|
|
},
|
|
"application/vnd.ms-package.obfuscated-opentype": {
|
|
source: "apache"
|
|
},
|
|
"application/vnd.ms-pki.seccat": {
|
|
source: "apache",
|
|
extensions: ["cat"]
|
|
},
|
|
"application/vnd.ms-pki.stl": {
|
|
source: "apache",
|
|
extensions: ["stl"]
|
|
},
|
|
"application/vnd.ms-playready.initiator+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-powerpoint": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["ppt", "pps", "pot"]
|
|
},
|
|
"application/vnd.ms-powerpoint.addin.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["ppam"]
|
|
},
|
|
"application/vnd.ms-powerpoint.presentation.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["pptm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.slide.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["sldm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["ppsm"]
|
|
},
|
|
"application/vnd.ms-powerpoint.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["potm"]
|
|
},
|
|
"application/vnd.ms-printdevicecapabilities+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-printing.printticket+xml": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-printschematicket+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ms-project": {
|
|
source: "iana",
|
|
extensions: ["mpp", "mpt"]
|
|
},
|
|
"application/vnd.ms-tnef": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.devicepairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.nwprinting.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.printerpairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-windows.wsd.oob": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-chlg-req": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.lic-resp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-chlg-req": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-wmdrm.meter-resp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ms-word.document.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["docm"]
|
|
},
|
|
"application/vnd.ms-word.template.macroenabled.12": {
|
|
source: "iana",
|
|
extensions: ["dotm"]
|
|
},
|
|
"application/vnd.ms-works": {
|
|
source: "iana",
|
|
extensions: ["wps", "wks", "wcm", "wdb"]
|
|
},
|
|
"application/vnd.ms-wpl": {
|
|
source: "iana",
|
|
extensions: ["wpl"]
|
|
},
|
|
"application/vnd.ms-xpsdocument": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["xps"]
|
|
},
|
|
"application/vnd.msa-disk-image": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.mseq": {
|
|
source: "iana",
|
|
extensions: ["mseq"]
|
|
},
|
|
"application/vnd.msign": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.multiad.creator": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.multiad.creator.cif": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.music-niff": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.musician": {
|
|
source: "iana",
|
|
extensions: ["mus"]
|
|
},
|
|
"application/vnd.muvee.style": {
|
|
source: "iana",
|
|
extensions: ["msty"]
|
|
},
|
|
"application/vnd.mynfc": {
|
|
source: "iana",
|
|
extensions: ["taglet"]
|
|
},
|
|
"application/vnd.nacamar.ybrid+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.ncd.control": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ncd.reference": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nearst.inv+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nebumind.line": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nervana": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.netfpx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.neurolanguage.nlu": {
|
|
source: "iana",
|
|
extensions: ["nlu"]
|
|
},
|
|
"application/vnd.nimn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nintendo.nitro.rom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nintendo.snes.rom": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nitf": {
|
|
source: "iana",
|
|
extensions: ["ntf", "nitf"]
|
|
},
|
|
"application/vnd.noblenet-directory": {
|
|
source: "iana",
|
|
extensions: ["nnd"]
|
|
},
|
|
"application/vnd.noblenet-sealer": {
|
|
source: "iana",
|
|
extensions: ["nns"]
|
|
},
|
|
"application/vnd.noblenet-web": {
|
|
source: "iana",
|
|
extensions: ["nnw"]
|
|
},
|
|
"application/vnd.nokia.catalogs": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.conml+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.conml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.iptv.config+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.isds-radio-presets": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.landmark+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.landmarkcollection+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.n-gage.ac+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ac"]
|
|
},
|
|
"application/vnd.nokia.n-gage.data": {
|
|
source: "iana",
|
|
extensions: ["ngdat"]
|
|
},
|
|
"application/vnd.nokia.n-gage.symbian.install": {
|
|
source: "iana",
|
|
extensions: ["n-gage"]
|
|
},
|
|
"application/vnd.nokia.ncd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.nokia.pcd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.nokia.radio-preset": {
|
|
source: "iana",
|
|
extensions: ["rpst"]
|
|
},
|
|
"application/vnd.nokia.radio-presets": {
|
|
source: "iana",
|
|
extensions: ["rpss"]
|
|
},
|
|
"application/vnd.novadigm.edm": {
|
|
source: "iana",
|
|
extensions: ["edm"]
|
|
},
|
|
"application/vnd.novadigm.edx": {
|
|
source: "iana",
|
|
extensions: ["edx"]
|
|
},
|
|
"application/vnd.novadigm.ext": {
|
|
source: "iana",
|
|
extensions: ["ext"]
|
|
},
|
|
"application/vnd.ntt-local.content-share": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.file-transfer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.ogw_remote-access": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_remote": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ntt-local.sip-ta_tcp_stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oasis.opendocument.chart": {
|
|
source: "iana",
|
|
extensions: ["odc"]
|
|
},
|
|
"application/vnd.oasis.opendocument.chart-template": {
|
|
source: "iana",
|
|
extensions: ["otc"]
|
|
},
|
|
"application/vnd.oasis.opendocument.database": {
|
|
source: "iana",
|
|
extensions: ["odb"]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula": {
|
|
source: "iana",
|
|
extensions: ["odf"]
|
|
},
|
|
"application/vnd.oasis.opendocument.formula-template": {
|
|
source: "iana",
|
|
extensions: ["odft"]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["odg"]
|
|
},
|
|
"application/vnd.oasis.opendocument.graphics-template": {
|
|
source: "iana",
|
|
extensions: ["otg"]
|
|
},
|
|
"application/vnd.oasis.opendocument.image": {
|
|
source: "iana",
|
|
extensions: ["odi"]
|
|
},
|
|
"application/vnd.oasis.opendocument.image-template": {
|
|
source: "iana",
|
|
extensions: ["oti"]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["odp"]
|
|
},
|
|
"application/vnd.oasis.opendocument.presentation-template": {
|
|
source: "iana",
|
|
extensions: ["otp"]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["ods"]
|
|
},
|
|
"application/vnd.oasis.opendocument.spreadsheet-template": {
|
|
source: "iana",
|
|
extensions: ["ots"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["odt"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-master": {
|
|
source: "iana",
|
|
extensions: ["odm"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-template": {
|
|
source: "iana",
|
|
extensions: ["ott"]
|
|
},
|
|
"application/vnd.oasis.opendocument.text-web": {
|
|
source: "iana",
|
|
extensions: ["oth"]
|
|
},
|
|
"application/vnd.obn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ocf+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oci.image.manifest.v1+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oftn.l10n+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.contentaccessdownload+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.contentaccessstreaming+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.cspg-hexbinary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oipf.dae.svg+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.dae.xhtml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.mippvcontrolmessage+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.pae.gem": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oipf.spdiscovery+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.spdlist+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.ueprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oipf.userprofile+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.olpc-sugar": {
|
|
source: "iana",
|
|
extensions: ["xo"]
|
|
},
|
|
"application/vnd.oma-scws-config": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-request": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma-scws-http-response": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.associated-procedure-parameter+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.drm-trigger+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.imd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.ltkm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.notification+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.provisioningtrigger": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgboot": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.sgdd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.sgdu": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.simple-symbol-container": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.bcast.smartcard-trigger+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.sprov+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.bcast.stkm": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.cab-address-book+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-feature-handler+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-pcc+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-subs-invite+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.cab-user-prefs+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.dcd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.dcdc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.dd2+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["dd2"]
|
|
},
|
|
"application/vnd.oma.drm.risd+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.group-usage-list+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.lwm2m+cbor": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.lwm2m+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.lwm2m+tlv": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.pal+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.detailed-progress-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.final-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.groups+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.invocation-descriptor+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.poc.optimized-progress-report+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.push": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.oma.scidm.messages+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oma.xcap-directory+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-email+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-file+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omads-folder+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.omaloc-supl-init": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepager": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertamp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertamx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertat": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertatp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.onepagertatx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openblox.game+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["obgx"]
|
|
},
|
|
"application/vnd.openblox.game-binary": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openeye.oeb": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openofficeorg.extension": {
|
|
source: "apache",
|
|
extensions: ["oxt"]
|
|
},
|
|
"application/vnd.openstreetmap.data+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["osm"]
|
|
},
|
|
"application/vnd.opentimestamps.ots": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.custom-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawing+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.extended-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["pptx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide": {
|
|
source: "iana",
|
|
extensions: ["sldx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
|
|
source: "iana",
|
|
extensions: ["ppsx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template": {
|
|
source: "iana",
|
|
extensions: ["potx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["xlsx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
|
|
source: "iana",
|
|
extensions: ["xltx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.theme+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.themeoverride+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.vmldrawing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["docx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
|
|
source: "iana",
|
|
extensions: ["dotx"]
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.core-properties+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.openxmlformats-package.relationships+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oracle.resource+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.orange.indata": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osa.netdeploy": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osgeo.mapguide.package": {
|
|
source: "iana",
|
|
extensions: ["mgp"]
|
|
},
|
|
"application/vnd.osgi.bundle": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.osgi.dp": {
|
|
source: "iana",
|
|
extensions: ["dp"]
|
|
},
|
|
"application/vnd.osgi.subsystem": {
|
|
source: "iana",
|
|
extensions: ["esa"]
|
|
},
|
|
"application/vnd.otps.ct-kip+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.oxli.countgraph": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pagerduty+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.palm": {
|
|
source: "iana",
|
|
extensions: ["pdb", "pqa", "oprc"]
|
|
},
|
|
"application/vnd.panoply": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.paos.xml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.patentdive": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.patientecommsdoc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pawaafile": {
|
|
source: "iana",
|
|
extensions: ["paw"]
|
|
},
|
|
"application/vnd.pcos": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pg.format": {
|
|
source: "iana",
|
|
extensions: ["str"]
|
|
},
|
|
"application/vnd.pg.osasli": {
|
|
source: "iana",
|
|
extensions: ["ei6"]
|
|
},
|
|
"application/vnd.piaccess.application-licence": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.picsel": {
|
|
source: "iana",
|
|
extensions: ["efif"]
|
|
},
|
|
"application/vnd.pmi.widget": {
|
|
source: "iana",
|
|
extensions: ["wg"]
|
|
},
|
|
"application/vnd.poc.group-advertisement+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.pocketlearn": {
|
|
source: "iana",
|
|
extensions: ["plf"]
|
|
},
|
|
"application/vnd.powerbuilder6": {
|
|
source: "iana",
|
|
extensions: ["pbd"]
|
|
},
|
|
"application/vnd.powerbuilder6-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder7": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder7-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder75": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.powerbuilder75-s": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.preminet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.previewsystems.box": {
|
|
source: "iana",
|
|
extensions: ["box"]
|
|
},
|
|
"application/vnd.proteus.magazine": {
|
|
source: "iana",
|
|
extensions: ["mgz"]
|
|
},
|
|
"application/vnd.psfs": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.publishare-delta-tree": {
|
|
source: "iana",
|
|
extensions: ["qps"]
|
|
},
|
|
"application/vnd.pvi.ptid1": {
|
|
source: "iana",
|
|
extensions: ["ptid"]
|
|
},
|
|
"application/vnd.pwg-multiplexed": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.pwg-xhtml-print+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.qualcomm.brew-app-res": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.quarantainenet": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.quark.quarkxpress": {
|
|
source: "iana",
|
|
extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"]
|
|
},
|
|
"application/vnd.quobject-quoxdocument": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.radisys.moml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-conn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-dialog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-audit-stream+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-conf+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-base+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-detect+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-group+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-speech+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.radisys.msml-dialog-transform+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.rainstor.data": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.rapid": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.rar": {
|
|
source: "iana",
|
|
extensions: ["rar"]
|
|
},
|
|
"application/vnd.realvnc.bed": {
|
|
source: "iana",
|
|
extensions: ["bed"]
|
|
},
|
|
"application/vnd.recordare.musicxml": {
|
|
source: "iana",
|
|
extensions: ["mxl"]
|
|
},
|
|
"application/vnd.recordare.musicxml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["musicxml"]
|
|
},
|
|
"application/vnd.renlearn.rlprint": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.resilient.logic": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.restful+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.rig.cryptonote": {
|
|
source: "iana",
|
|
extensions: ["cryptonote"]
|
|
},
|
|
"application/vnd.rim.cod": {
|
|
source: "apache",
|
|
extensions: ["cod"]
|
|
},
|
|
"application/vnd.rn-realmedia": {
|
|
source: "apache",
|
|
extensions: ["rm"]
|
|
},
|
|
"application/vnd.rn-realmedia-vbr": {
|
|
source: "apache",
|
|
extensions: ["rmvb"]
|
|
},
|
|
"application/vnd.route66.link66+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["link66"]
|
|
},
|
|
"application/vnd.rs-274x": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ruckus.download": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.s3sms": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sailingtracker.track": {
|
|
source: "iana",
|
|
extensions: ["st"]
|
|
},
|
|
"application/vnd.sar": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sbm.cid": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sbm.mid2": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.scribus": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.3df": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.csf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.doc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.eml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.mht": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.net": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.ppt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.tiff": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealed.xls": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.html": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sealedmedia.softseal.pdf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.seemail": {
|
|
source: "iana",
|
|
extensions: ["see"]
|
|
},
|
|
"application/vnd.seis+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.sema": {
|
|
source: "iana",
|
|
extensions: ["sema"]
|
|
},
|
|
"application/vnd.semd": {
|
|
source: "iana",
|
|
extensions: ["semd"]
|
|
},
|
|
"application/vnd.semf": {
|
|
source: "iana",
|
|
extensions: ["semf"]
|
|
},
|
|
"application/vnd.shade-save-file": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.shana.informed.formdata": {
|
|
source: "iana",
|
|
extensions: ["ifm"]
|
|
},
|
|
"application/vnd.shana.informed.formtemplate": {
|
|
source: "iana",
|
|
extensions: ["itp"]
|
|
},
|
|
"application/vnd.shana.informed.interchange": {
|
|
source: "iana",
|
|
extensions: ["iif"]
|
|
},
|
|
"application/vnd.shana.informed.package": {
|
|
source: "iana",
|
|
extensions: ["ipk"]
|
|
},
|
|
"application/vnd.shootproof+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.shopkick+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.shp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.shx": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sigrok.session": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.simtech-mindmapper": {
|
|
source: "iana",
|
|
extensions: ["twd", "twds"]
|
|
},
|
|
"application/vnd.siren+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.smaf": {
|
|
source: "iana",
|
|
extensions: ["mmf"]
|
|
},
|
|
"application/vnd.smart.notebook": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.smart.teacher": {
|
|
source: "iana",
|
|
extensions: ["teacher"]
|
|
},
|
|
"application/vnd.snesdev-page-table": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.software602.filler.form+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["fo"]
|
|
},
|
|
"application/vnd.software602.filler.form-xml-zip": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.solent.sdkm+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["sdkm", "sdkd"]
|
|
},
|
|
"application/vnd.spotfire.dxp": {
|
|
source: "iana",
|
|
extensions: ["dxp"]
|
|
},
|
|
"application/vnd.spotfire.sfs": {
|
|
source: "iana",
|
|
extensions: ["sfs"]
|
|
},
|
|
"application/vnd.sqlite3": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-cod": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-dtf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sss-ntf": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.stardivision.calc": {
|
|
source: "apache",
|
|
extensions: ["sdc"]
|
|
},
|
|
"application/vnd.stardivision.draw": {
|
|
source: "apache",
|
|
extensions: ["sda"]
|
|
},
|
|
"application/vnd.stardivision.impress": {
|
|
source: "apache",
|
|
extensions: ["sdd"]
|
|
},
|
|
"application/vnd.stardivision.math": {
|
|
source: "apache",
|
|
extensions: ["smf"]
|
|
},
|
|
"application/vnd.stardivision.writer": {
|
|
source: "apache",
|
|
extensions: ["sdw", "vor"]
|
|
},
|
|
"application/vnd.stardivision.writer-global": {
|
|
source: "apache",
|
|
extensions: ["sgl"]
|
|
},
|
|
"application/vnd.stepmania.package": {
|
|
source: "iana",
|
|
extensions: ["smzip"]
|
|
},
|
|
"application/vnd.stepmania.stepchart": {
|
|
source: "iana",
|
|
extensions: ["sm"]
|
|
},
|
|
"application/vnd.street-stream": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sun.wadl+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wadl"]
|
|
},
|
|
"application/vnd.sun.xml.calc": {
|
|
source: "apache",
|
|
extensions: ["sxc"]
|
|
},
|
|
"application/vnd.sun.xml.calc.template": {
|
|
source: "apache",
|
|
extensions: ["stc"]
|
|
},
|
|
"application/vnd.sun.xml.draw": {
|
|
source: "apache",
|
|
extensions: ["sxd"]
|
|
},
|
|
"application/vnd.sun.xml.draw.template": {
|
|
source: "apache",
|
|
extensions: ["std"]
|
|
},
|
|
"application/vnd.sun.xml.impress": {
|
|
source: "apache",
|
|
extensions: ["sxi"]
|
|
},
|
|
"application/vnd.sun.xml.impress.template": {
|
|
source: "apache",
|
|
extensions: ["sti"]
|
|
},
|
|
"application/vnd.sun.xml.math": {
|
|
source: "apache",
|
|
extensions: ["sxm"]
|
|
},
|
|
"application/vnd.sun.xml.writer": {
|
|
source: "apache",
|
|
extensions: ["sxw"]
|
|
},
|
|
"application/vnd.sun.xml.writer.global": {
|
|
source: "apache",
|
|
extensions: ["sxg"]
|
|
},
|
|
"application/vnd.sun.xml.writer.template": {
|
|
source: "apache",
|
|
extensions: ["stw"]
|
|
},
|
|
"application/vnd.sus-calendar": {
|
|
source: "iana",
|
|
extensions: ["sus", "susp"]
|
|
},
|
|
"application/vnd.svd": {
|
|
source: "iana",
|
|
extensions: ["svd"]
|
|
},
|
|
"application/vnd.swiftview-ics": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.sycle+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.syft+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.symbian.install": {
|
|
source: "apache",
|
|
extensions: ["sis", "sisx"]
|
|
},
|
|
"application/vnd.syncml+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["xsm"]
|
|
},
|
|
"application/vnd.syncml.dm+wbxml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: ["bdm"]
|
|
},
|
|
"application/vnd.syncml.dm+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["xdm"]
|
|
},
|
|
"application/vnd.syncml.dm.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmddf+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["ddf"]
|
|
},
|
|
"application/vnd.syncml.dmtnds+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.syncml.dmtnds+xml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true
|
|
},
|
|
"application/vnd.syncml.ds.notification": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.tableschema+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tao.intent-module-archive": {
|
|
source: "iana",
|
|
extensions: ["tao"]
|
|
},
|
|
"application/vnd.tcpdump.pcap": {
|
|
source: "iana",
|
|
extensions: ["pcap", "cap", "dmp"]
|
|
},
|
|
"application/vnd.think-cell.ppttc+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tmd.mediaflex.api+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.tml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.tmobile-livetv": {
|
|
source: "iana",
|
|
extensions: ["tmo"]
|
|
},
|
|
"application/vnd.tri.onesource": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.trid.tpt": {
|
|
source: "iana",
|
|
extensions: ["tpt"]
|
|
},
|
|
"application/vnd.triscape.mxs": {
|
|
source: "iana",
|
|
extensions: ["mxs"]
|
|
},
|
|
"application/vnd.trueapp": {
|
|
source: "iana",
|
|
extensions: ["tra"]
|
|
},
|
|
"application/vnd.truedoc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ubisoft.webplayer": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ufdl": {
|
|
source: "iana",
|
|
extensions: ["ufd", "ufdl"]
|
|
},
|
|
"application/vnd.uiq.theme": {
|
|
source: "iana",
|
|
extensions: ["utz"]
|
|
},
|
|
"application/vnd.umajin": {
|
|
source: "iana",
|
|
extensions: ["umj"]
|
|
},
|
|
"application/vnd.unity": {
|
|
source: "iana",
|
|
extensions: ["unityweb"]
|
|
},
|
|
"application/vnd.uoml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["uoml"]
|
|
},
|
|
"application/vnd.uplanet.alert": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.alert-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.bearer-choice-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.cacheop-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.channel": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.channel-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.list": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.list-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.listcmd-wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uplanet.signal": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.uri-map": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.valve.source.material": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vcx": {
|
|
source: "iana",
|
|
extensions: ["vcx"]
|
|
},
|
|
"application/vnd.vd-study": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vectorworks": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vel+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.verimatrix.vcas": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.veritone.aion+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.veryant.thin": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.ves.encrypted": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vidsoft.vidconference": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.visio": {
|
|
source: "iana",
|
|
extensions: ["vsd", "vst", "vss", "vsw"]
|
|
},
|
|
"application/vnd.visionary": {
|
|
source: "iana",
|
|
extensions: ["vis"]
|
|
},
|
|
"application/vnd.vividence.scriptfile": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.vsf": {
|
|
source: "iana",
|
|
extensions: ["vsf"]
|
|
},
|
|
"application/vnd.wap.sic": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wap.slc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wap.wbxml": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: ["wbxml"]
|
|
},
|
|
"application/vnd.wap.wmlc": {
|
|
source: "iana",
|
|
extensions: ["wmlc"]
|
|
},
|
|
"application/vnd.wap.wmlscriptc": {
|
|
source: "iana",
|
|
extensions: ["wmlsc"]
|
|
},
|
|
"application/vnd.webturbo": {
|
|
source: "iana",
|
|
extensions: ["wtb"]
|
|
},
|
|
"application/vnd.wfa.dpp": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wfa.p2p": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wfa.wsc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.windows.devicepairing": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wmc": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wmf.bootstrap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.mathematica.package": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wolfram.player": {
|
|
source: "iana",
|
|
extensions: ["nbp"]
|
|
},
|
|
"application/vnd.wordperfect": {
|
|
source: "iana",
|
|
extensions: ["wpd"]
|
|
},
|
|
"application/vnd.wqd": {
|
|
source: "iana",
|
|
extensions: ["wqd"]
|
|
},
|
|
"application/vnd.wrq-hp3000-labelled": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wt.stf": {
|
|
source: "iana",
|
|
extensions: ["stf"]
|
|
},
|
|
"application/vnd.wv.csp+wbxml": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.wv.csp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.wv.ssp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xacml+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xara": {
|
|
source: "iana",
|
|
extensions: ["xar"]
|
|
},
|
|
"application/vnd.xfdl": {
|
|
source: "iana",
|
|
extensions: ["xfdl"]
|
|
},
|
|
"application/vnd.xfdl.webform": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmi+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vnd.xmpie.cpkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.dpkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.plan": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.ppkg": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.xmpie.xlim": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.hv-dic": {
|
|
source: "iana",
|
|
extensions: ["hvd"]
|
|
},
|
|
"application/vnd.yamaha.hv-script": {
|
|
source: "iana",
|
|
extensions: ["hvs"]
|
|
},
|
|
"application/vnd.yamaha.hv-voice": {
|
|
source: "iana",
|
|
extensions: ["hvp"]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat": {
|
|
source: "iana",
|
|
extensions: ["osf"]
|
|
},
|
|
"application/vnd.yamaha.openscoreformat.osfpvg+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["osfpvg"]
|
|
},
|
|
"application/vnd.yamaha.remote-setup": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.smaf-audio": {
|
|
source: "iana",
|
|
extensions: ["saf"]
|
|
},
|
|
"application/vnd.yamaha.smaf-phrase": {
|
|
source: "iana",
|
|
extensions: ["spf"]
|
|
},
|
|
"application/vnd.yamaha.through-ngn": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yamaha.tunnel-udpencap": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yaoweme": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.yellowriver-custom-menu": {
|
|
source: "iana",
|
|
extensions: ["cmp"]
|
|
},
|
|
"application/vnd.youtube.yt": {
|
|
source: "iana"
|
|
},
|
|
"application/vnd.zul": {
|
|
source: "iana",
|
|
extensions: ["zir", "zirz"]
|
|
},
|
|
"application/vnd.zzazz.deck+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["zaz"]
|
|
},
|
|
"application/voicexml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["vxml"]
|
|
},
|
|
"application/voucher-cms+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/vq-rtcpxr": {
|
|
source: "iana"
|
|
},
|
|
"application/wasm": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wasm"]
|
|
},
|
|
"application/watcherinfo+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wif"]
|
|
},
|
|
"application/webpush-options+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/whoispp-query": {
|
|
source: "iana"
|
|
},
|
|
"application/whoispp-response": {
|
|
source: "iana"
|
|
},
|
|
"application/widget": {
|
|
source: "iana",
|
|
extensions: ["wgt"]
|
|
},
|
|
"application/winhlp": {
|
|
source: "apache",
|
|
extensions: ["hlp"]
|
|
},
|
|
"application/wita": {
|
|
source: "iana"
|
|
},
|
|
"application/wordperfect5.1": {
|
|
source: "iana"
|
|
},
|
|
"application/wsdl+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wsdl"]
|
|
},
|
|
"application/wspolicy+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["wspolicy"]
|
|
},
|
|
"application/x-7z-compressed": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["7z"]
|
|
},
|
|
"application/x-abiword": {
|
|
source: "apache",
|
|
extensions: ["abw"]
|
|
},
|
|
"application/x-ace-compressed": {
|
|
source: "apache",
|
|
extensions: ["ace"]
|
|
},
|
|
"application/x-amf": {
|
|
source: "apache"
|
|
},
|
|
"application/x-apple-diskimage": {
|
|
source: "apache",
|
|
extensions: ["dmg"]
|
|
},
|
|
"application/x-arj": {
|
|
compressible: false,
|
|
extensions: ["arj"]
|
|
},
|
|
"application/x-authorware-bin": {
|
|
source: "apache",
|
|
extensions: ["aab", "x32", "u32", "vox"]
|
|
},
|
|
"application/x-authorware-map": {
|
|
source: "apache",
|
|
extensions: ["aam"]
|
|
},
|
|
"application/x-authorware-seg": {
|
|
source: "apache",
|
|
extensions: ["aas"]
|
|
},
|
|
"application/x-bcpio": {
|
|
source: "apache",
|
|
extensions: ["bcpio"]
|
|
},
|
|
"application/x-bdoc": {
|
|
compressible: false,
|
|
extensions: ["bdoc"]
|
|
},
|
|
"application/x-bittorrent": {
|
|
source: "apache",
|
|
extensions: ["torrent"]
|
|
},
|
|
"application/x-blorb": {
|
|
source: "apache",
|
|
extensions: ["blb", "blorb"]
|
|
},
|
|
"application/x-bzip": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["bz"]
|
|
},
|
|
"application/x-bzip2": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["bz2", "boz"]
|
|
},
|
|
"application/x-cbr": {
|
|
source: "apache",
|
|
extensions: ["cbr", "cba", "cbt", "cbz", "cb7"]
|
|
},
|
|
"application/x-cdlink": {
|
|
source: "apache",
|
|
extensions: ["vcd"]
|
|
},
|
|
"application/x-cfs-compressed": {
|
|
source: "apache",
|
|
extensions: ["cfs"]
|
|
},
|
|
"application/x-chat": {
|
|
source: "apache",
|
|
extensions: ["chat"]
|
|
},
|
|
"application/x-chess-pgn": {
|
|
source: "apache",
|
|
extensions: ["pgn"]
|
|
},
|
|
"application/x-chrome-extension": {
|
|
extensions: ["crx"]
|
|
},
|
|
"application/x-cocoa": {
|
|
source: "nginx",
|
|
extensions: ["cco"]
|
|
},
|
|
"application/x-compress": {
|
|
source: "apache"
|
|
},
|
|
"application/x-conference": {
|
|
source: "apache",
|
|
extensions: ["nsc"]
|
|
},
|
|
"application/x-cpio": {
|
|
source: "apache",
|
|
extensions: ["cpio"]
|
|
},
|
|
"application/x-csh": {
|
|
source: "apache",
|
|
extensions: ["csh"]
|
|
},
|
|
"application/x-deb": {
|
|
compressible: false
|
|
},
|
|
"application/x-debian-package": {
|
|
source: "apache",
|
|
extensions: ["deb", "udeb"]
|
|
},
|
|
"application/x-dgc-compressed": {
|
|
source: "apache",
|
|
extensions: ["dgc"]
|
|
},
|
|
"application/x-director": {
|
|
source: "apache",
|
|
extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"]
|
|
},
|
|
"application/x-doom": {
|
|
source: "apache",
|
|
extensions: ["wad"]
|
|
},
|
|
"application/x-dtbncx+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["ncx"]
|
|
},
|
|
"application/x-dtbook+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["dtb"]
|
|
},
|
|
"application/x-dtbresource+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["res"]
|
|
},
|
|
"application/x-dvi": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["dvi"]
|
|
},
|
|
"application/x-envoy": {
|
|
source: "apache",
|
|
extensions: ["evy"]
|
|
},
|
|
"application/x-eva": {
|
|
source: "apache",
|
|
extensions: ["eva"]
|
|
},
|
|
"application/x-font-bdf": {
|
|
source: "apache",
|
|
extensions: ["bdf"]
|
|
},
|
|
"application/x-font-dos": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-framemaker": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-ghostscript": {
|
|
source: "apache",
|
|
extensions: ["gsf"]
|
|
},
|
|
"application/x-font-libgrx": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-linux-psf": {
|
|
source: "apache",
|
|
extensions: ["psf"]
|
|
},
|
|
"application/x-font-pcf": {
|
|
source: "apache",
|
|
extensions: ["pcf"]
|
|
},
|
|
"application/x-font-snf": {
|
|
source: "apache",
|
|
extensions: ["snf"]
|
|
},
|
|
"application/x-font-speedo": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-sunos-news": {
|
|
source: "apache"
|
|
},
|
|
"application/x-font-type1": {
|
|
source: "apache",
|
|
extensions: ["pfa", "pfb", "pfm", "afm"]
|
|
},
|
|
"application/x-font-vfont": {
|
|
source: "apache"
|
|
},
|
|
"application/x-freearc": {
|
|
source: "apache",
|
|
extensions: ["arc"]
|
|
},
|
|
"application/x-futuresplash": {
|
|
source: "apache",
|
|
extensions: ["spl"]
|
|
},
|
|
"application/x-gca-compressed": {
|
|
source: "apache",
|
|
extensions: ["gca"]
|
|
},
|
|
"application/x-glulx": {
|
|
source: "apache",
|
|
extensions: ["ulx"]
|
|
},
|
|
"application/x-gnumeric": {
|
|
source: "apache",
|
|
extensions: ["gnumeric"]
|
|
},
|
|
"application/x-gramps-xml": {
|
|
source: "apache",
|
|
extensions: ["gramps"]
|
|
},
|
|
"application/x-gtar": {
|
|
source: "apache",
|
|
extensions: ["gtar"]
|
|
},
|
|
"application/x-gzip": {
|
|
source: "apache"
|
|
},
|
|
"application/x-hdf": {
|
|
source: "apache",
|
|
extensions: ["hdf"]
|
|
},
|
|
"application/x-httpd-php": {
|
|
compressible: true,
|
|
extensions: ["php"]
|
|
},
|
|
"application/x-install-instructions": {
|
|
source: "apache",
|
|
extensions: ["install"]
|
|
},
|
|
"application/x-iso9660-image": {
|
|
source: "apache",
|
|
extensions: ["iso"]
|
|
},
|
|
"application/x-iwork-keynote-sffkey": {
|
|
extensions: ["key"]
|
|
},
|
|
"application/x-iwork-numbers-sffnumbers": {
|
|
extensions: ["numbers"]
|
|
},
|
|
"application/x-iwork-pages-sffpages": {
|
|
extensions: ["pages"]
|
|
},
|
|
"application/x-java-archive-diff": {
|
|
source: "nginx",
|
|
extensions: ["jardiff"]
|
|
},
|
|
"application/x-java-jnlp-file": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["jnlp"]
|
|
},
|
|
"application/x-javascript": {
|
|
compressible: true
|
|
},
|
|
"application/x-keepass2": {
|
|
extensions: ["kdbx"]
|
|
},
|
|
"application/x-latex": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["latex"]
|
|
},
|
|
"application/x-lua-bytecode": {
|
|
extensions: ["luac"]
|
|
},
|
|
"application/x-lzh-compressed": {
|
|
source: "apache",
|
|
extensions: ["lzh", "lha"]
|
|
},
|
|
"application/x-makeself": {
|
|
source: "nginx",
|
|
extensions: ["run"]
|
|
},
|
|
"application/x-mie": {
|
|
source: "apache",
|
|
extensions: ["mie"]
|
|
},
|
|
"application/x-mobipocket-ebook": {
|
|
source: "apache",
|
|
extensions: ["prc", "mobi"]
|
|
},
|
|
"application/x-mpegurl": {
|
|
compressible: false
|
|
},
|
|
"application/x-ms-application": {
|
|
source: "apache",
|
|
extensions: ["application"]
|
|
},
|
|
"application/x-ms-shortcut": {
|
|
source: "apache",
|
|
extensions: ["lnk"]
|
|
},
|
|
"application/x-ms-wmd": {
|
|
source: "apache",
|
|
extensions: ["wmd"]
|
|
},
|
|
"application/x-ms-wmz": {
|
|
source: "apache",
|
|
extensions: ["wmz"]
|
|
},
|
|
"application/x-ms-xbap": {
|
|
source: "apache",
|
|
extensions: ["xbap"]
|
|
},
|
|
"application/x-msaccess": {
|
|
source: "apache",
|
|
extensions: ["mdb"]
|
|
},
|
|
"application/x-msbinder": {
|
|
source: "apache",
|
|
extensions: ["obd"]
|
|
},
|
|
"application/x-mscardfile": {
|
|
source: "apache",
|
|
extensions: ["crd"]
|
|
},
|
|
"application/x-msclip": {
|
|
source: "apache",
|
|
extensions: ["clp"]
|
|
},
|
|
"application/x-msdos-program": {
|
|
extensions: ["exe"]
|
|
},
|
|
"application/x-msdownload": {
|
|
source: "apache",
|
|
extensions: ["exe", "dll", "com", "bat", "msi"]
|
|
},
|
|
"application/x-msmediaview": {
|
|
source: "apache",
|
|
extensions: ["mvb", "m13", "m14"]
|
|
},
|
|
"application/x-msmetafile": {
|
|
source: "apache",
|
|
extensions: ["wmf", "wmz", "emf", "emz"]
|
|
},
|
|
"application/x-msmoney": {
|
|
source: "apache",
|
|
extensions: ["mny"]
|
|
},
|
|
"application/x-mspublisher": {
|
|
source: "apache",
|
|
extensions: ["pub"]
|
|
},
|
|
"application/x-msschedule": {
|
|
source: "apache",
|
|
extensions: ["scd"]
|
|
},
|
|
"application/x-msterminal": {
|
|
source: "apache",
|
|
extensions: ["trm"]
|
|
},
|
|
"application/x-mswrite": {
|
|
source: "apache",
|
|
extensions: ["wri"]
|
|
},
|
|
"application/x-netcdf": {
|
|
source: "apache",
|
|
extensions: ["nc", "cdf"]
|
|
},
|
|
"application/x-ns-proxy-autoconfig": {
|
|
compressible: true,
|
|
extensions: ["pac"]
|
|
},
|
|
"application/x-nzb": {
|
|
source: "apache",
|
|
extensions: ["nzb"]
|
|
},
|
|
"application/x-perl": {
|
|
source: "nginx",
|
|
extensions: ["pl", "pm"]
|
|
},
|
|
"application/x-pilot": {
|
|
source: "nginx",
|
|
extensions: ["prc", "pdb"]
|
|
},
|
|
"application/x-pkcs12": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["p12", "pfx"]
|
|
},
|
|
"application/x-pkcs7-certificates": {
|
|
source: "apache",
|
|
extensions: ["p7b", "spc"]
|
|
},
|
|
"application/x-pkcs7-certreqresp": {
|
|
source: "apache",
|
|
extensions: ["p7r"]
|
|
},
|
|
"application/x-pki-message": {
|
|
source: "iana"
|
|
},
|
|
"application/x-rar-compressed": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["rar"]
|
|
},
|
|
"application/x-redhat-package-manager": {
|
|
source: "nginx",
|
|
extensions: ["rpm"]
|
|
},
|
|
"application/x-research-info-systems": {
|
|
source: "apache",
|
|
extensions: ["ris"]
|
|
},
|
|
"application/x-sea": {
|
|
source: "nginx",
|
|
extensions: ["sea"]
|
|
},
|
|
"application/x-sh": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["sh"]
|
|
},
|
|
"application/x-shar": {
|
|
source: "apache",
|
|
extensions: ["shar"]
|
|
},
|
|
"application/x-shockwave-flash": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["swf"]
|
|
},
|
|
"application/x-silverlight-app": {
|
|
source: "apache",
|
|
extensions: ["xap"]
|
|
},
|
|
"application/x-sql": {
|
|
source: "apache",
|
|
extensions: ["sql"]
|
|
},
|
|
"application/x-stuffit": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["sit"]
|
|
},
|
|
"application/x-stuffitx": {
|
|
source: "apache",
|
|
extensions: ["sitx"]
|
|
},
|
|
"application/x-subrip": {
|
|
source: "apache",
|
|
extensions: ["srt"]
|
|
},
|
|
"application/x-sv4cpio": {
|
|
source: "apache",
|
|
extensions: ["sv4cpio"]
|
|
},
|
|
"application/x-sv4crc": {
|
|
source: "apache",
|
|
extensions: ["sv4crc"]
|
|
},
|
|
"application/x-t3vm-image": {
|
|
source: "apache",
|
|
extensions: ["t3"]
|
|
},
|
|
"application/x-tads": {
|
|
source: "apache",
|
|
extensions: ["gam"]
|
|
},
|
|
"application/x-tar": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["tar"]
|
|
},
|
|
"application/x-tcl": {
|
|
source: "apache",
|
|
extensions: ["tcl", "tk"]
|
|
},
|
|
"application/x-tex": {
|
|
source: "apache",
|
|
extensions: ["tex"]
|
|
},
|
|
"application/x-tex-tfm": {
|
|
source: "apache",
|
|
extensions: ["tfm"]
|
|
},
|
|
"application/x-texinfo": {
|
|
source: "apache",
|
|
extensions: ["texinfo", "texi"]
|
|
},
|
|
"application/x-tgif": {
|
|
source: "apache",
|
|
extensions: ["obj"]
|
|
},
|
|
"application/x-ustar": {
|
|
source: "apache",
|
|
extensions: ["ustar"]
|
|
},
|
|
"application/x-virtualbox-hdd": {
|
|
compressible: true,
|
|
extensions: ["hdd"]
|
|
},
|
|
"application/x-virtualbox-ova": {
|
|
compressible: true,
|
|
extensions: ["ova"]
|
|
},
|
|
"application/x-virtualbox-ovf": {
|
|
compressible: true,
|
|
extensions: ["ovf"]
|
|
},
|
|
"application/x-virtualbox-vbox": {
|
|
compressible: true,
|
|
extensions: ["vbox"]
|
|
},
|
|
"application/x-virtualbox-vbox-extpack": {
|
|
compressible: false,
|
|
extensions: ["vbox-extpack"]
|
|
},
|
|
"application/x-virtualbox-vdi": {
|
|
compressible: true,
|
|
extensions: ["vdi"]
|
|
},
|
|
"application/x-virtualbox-vhd": {
|
|
compressible: true,
|
|
extensions: ["vhd"]
|
|
},
|
|
"application/x-virtualbox-vmdk": {
|
|
compressible: true,
|
|
extensions: ["vmdk"]
|
|
},
|
|
"application/x-wais-source": {
|
|
source: "apache",
|
|
extensions: ["src"]
|
|
},
|
|
"application/x-web-app-manifest+json": {
|
|
compressible: true,
|
|
extensions: ["webapp"]
|
|
},
|
|
"application/x-www-form-urlencoded": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/x-x509-ca-cert": {
|
|
source: "iana",
|
|
extensions: ["der", "crt", "pem"]
|
|
},
|
|
"application/x-x509-ca-ra-cert": {
|
|
source: "iana"
|
|
},
|
|
"application/x-x509-next-ca-cert": {
|
|
source: "iana"
|
|
},
|
|
"application/x-xfig": {
|
|
source: "apache",
|
|
extensions: ["fig"]
|
|
},
|
|
"application/x-xliff+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["xlf"]
|
|
},
|
|
"application/x-xpinstall": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["xpi"]
|
|
},
|
|
"application/x-xz": {
|
|
source: "apache",
|
|
extensions: ["xz"]
|
|
},
|
|
"application/x-zmachine": {
|
|
source: "apache",
|
|
extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"]
|
|
},
|
|
"application/x400-bp": {
|
|
source: "iana"
|
|
},
|
|
"application/xacml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xaml+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["xaml"]
|
|
},
|
|
"application/xcap-att+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xav"]
|
|
},
|
|
"application/xcap-caps+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xca"]
|
|
},
|
|
"application/xcap-diff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xdf"]
|
|
},
|
|
"application/xcap-el+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xel"]
|
|
},
|
|
"application/xcap-error+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xcap-ns+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xns"]
|
|
},
|
|
"application/xcon-conference-info+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xcon-conference-info-diff+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xenc+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xenc"]
|
|
},
|
|
"application/xhtml+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xhtml", "xht"]
|
|
},
|
|
"application/xhtml-voice+xml": {
|
|
source: "apache",
|
|
compressible: true
|
|
},
|
|
"application/xliff+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xlf"]
|
|
},
|
|
"application/xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xml", "xsl", "xsd", "rng"]
|
|
},
|
|
"application/xml-dtd": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["dtd"]
|
|
},
|
|
"application/xml-external-parsed-entity": {
|
|
source: "iana"
|
|
},
|
|
"application/xml-patch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xmpp+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/xop+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xop"]
|
|
},
|
|
"application/xproc+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["xpl"]
|
|
},
|
|
"application/xslt+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xsl", "xslt"]
|
|
},
|
|
"application/xspf+xml": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["xspf"]
|
|
},
|
|
"application/xv+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["mxml", "xhvml", "xvml", "xvm"]
|
|
},
|
|
"application/yang": {
|
|
source: "iana",
|
|
extensions: ["yang"]
|
|
},
|
|
"application/yang-data+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-data+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-patch+json": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yang-patch+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"application/yin+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["yin"]
|
|
},
|
|
"application/zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["zip"]
|
|
},
|
|
"application/zlib": {
|
|
source: "iana"
|
|
},
|
|
"application/zstd": {
|
|
source: "iana"
|
|
},
|
|
"audio/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/32kadpcm": {
|
|
source: "iana"
|
|
},
|
|
"audio/3gpp": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["3gpp"]
|
|
},
|
|
"audio/3gpp2": {
|
|
source: "iana"
|
|
},
|
|
"audio/aac": {
|
|
source: "iana"
|
|
},
|
|
"audio/ac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/adpcm": {
|
|
source: "apache",
|
|
extensions: ["adp"]
|
|
},
|
|
"audio/amr": {
|
|
source: "iana",
|
|
extensions: ["amr"]
|
|
},
|
|
"audio/amr-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/amr-wb+": {
|
|
source: "iana"
|
|
},
|
|
"audio/aptx": {
|
|
source: "iana"
|
|
},
|
|
"audio/asc": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac-advanced-lossless": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac-x": {
|
|
source: "iana"
|
|
},
|
|
"audio/atrac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/basic": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["au", "snd"]
|
|
},
|
|
"audio/bv16": {
|
|
source: "iana"
|
|
},
|
|
"audio/bv32": {
|
|
source: "iana"
|
|
},
|
|
"audio/clearmode": {
|
|
source: "iana"
|
|
},
|
|
"audio/cn": {
|
|
source: "iana"
|
|
},
|
|
"audio/dat12": {
|
|
source: "iana"
|
|
},
|
|
"audio/dls": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es201108": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202050": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202211": {
|
|
source: "iana"
|
|
},
|
|
"audio/dsr-es202212": {
|
|
source: "iana"
|
|
},
|
|
"audio/dv": {
|
|
source: "iana"
|
|
},
|
|
"audio/dvi4": {
|
|
source: "iana"
|
|
},
|
|
"audio/eac3": {
|
|
source: "iana"
|
|
},
|
|
"audio/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc-qcp": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrc1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcb1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcnw1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb0": {
|
|
source: "iana"
|
|
},
|
|
"audio/evrcwb1": {
|
|
source: "iana"
|
|
},
|
|
"audio/evs": {
|
|
source: "iana"
|
|
},
|
|
"audio/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/fwdred": {
|
|
source: "iana"
|
|
},
|
|
"audio/g711-0": {
|
|
source: "iana"
|
|
},
|
|
"audio/g719": {
|
|
source: "iana"
|
|
},
|
|
"audio/g722": {
|
|
source: "iana"
|
|
},
|
|
"audio/g7221": {
|
|
source: "iana"
|
|
},
|
|
"audio/g723": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-16": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-24": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-32": {
|
|
source: "iana"
|
|
},
|
|
"audio/g726-40": {
|
|
source: "iana"
|
|
},
|
|
"audio/g728": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729": {
|
|
source: "iana"
|
|
},
|
|
"audio/g7291": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729d": {
|
|
source: "iana"
|
|
},
|
|
"audio/g729e": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm-efr": {
|
|
source: "iana"
|
|
},
|
|
"audio/gsm-hr-08": {
|
|
source: "iana"
|
|
},
|
|
"audio/ilbc": {
|
|
source: "iana"
|
|
},
|
|
"audio/ip-mr_v2.5": {
|
|
source: "iana"
|
|
},
|
|
"audio/isac": {
|
|
source: "apache"
|
|
},
|
|
"audio/l16": {
|
|
source: "iana"
|
|
},
|
|
"audio/l20": {
|
|
source: "iana"
|
|
},
|
|
"audio/l24": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"audio/l8": {
|
|
source: "iana"
|
|
},
|
|
"audio/lpc": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp1200": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp2400": {
|
|
source: "iana"
|
|
},
|
|
"audio/melp600": {
|
|
source: "iana"
|
|
},
|
|
"audio/mhas": {
|
|
source: "iana"
|
|
},
|
|
"audio/midi": {
|
|
source: "apache",
|
|
extensions: ["mid", "midi", "kar", "rmi"]
|
|
},
|
|
"audio/mobile-xmf": {
|
|
source: "iana",
|
|
extensions: ["mxmf"]
|
|
},
|
|
"audio/mp3": {
|
|
compressible: false,
|
|
extensions: ["mp3"]
|
|
},
|
|
"audio/mp4": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["m4a", "mp4a"]
|
|
},
|
|
"audio/mp4a-latm": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpa": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpa-robust": {
|
|
source: "iana"
|
|
},
|
|
"audio/mpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"]
|
|
},
|
|
"audio/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"audio/musepack": {
|
|
source: "apache"
|
|
},
|
|
"audio/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["oga", "ogg", "spx", "opus"]
|
|
},
|
|
"audio/opus": {
|
|
source: "iana"
|
|
},
|
|
"audio/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcma": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcma-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcmu": {
|
|
source: "iana"
|
|
},
|
|
"audio/pcmu-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/prs.sid": {
|
|
source: "iana"
|
|
},
|
|
"audio/qcelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/red": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtp-midi": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"audio/rtx": {
|
|
source: "iana"
|
|
},
|
|
"audio/s3m": {
|
|
source: "apache",
|
|
extensions: ["s3m"]
|
|
},
|
|
"audio/scip": {
|
|
source: "iana"
|
|
},
|
|
"audio/silk": {
|
|
source: "apache",
|
|
extensions: ["sil"]
|
|
},
|
|
"audio/smv": {
|
|
source: "iana"
|
|
},
|
|
"audio/smv-qcp": {
|
|
source: "iana"
|
|
},
|
|
"audio/smv0": {
|
|
source: "iana"
|
|
},
|
|
"audio/sofa": {
|
|
source: "iana"
|
|
},
|
|
"audio/sp-midi": {
|
|
source: "iana"
|
|
},
|
|
"audio/speex": {
|
|
source: "iana"
|
|
},
|
|
"audio/t140c": {
|
|
source: "iana"
|
|
},
|
|
"audio/t38": {
|
|
source: "iana"
|
|
},
|
|
"audio/telephone-event": {
|
|
source: "iana"
|
|
},
|
|
"audio/tetra_acelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/tetra_acelp_bb": {
|
|
source: "iana"
|
|
},
|
|
"audio/tone": {
|
|
source: "iana"
|
|
},
|
|
"audio/tsvcis": {
|
|
source: "iana"
|
|
},
|
|
"audio/uemclip": {
|
|
source: "iana"
|
|
},
|
|
"audio/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"audio/usac": {
|
|
source: "iana"
|
|
},
|
|
"audio/vdvi": {
|
|
source: "iana"
|
|
},
|
|
"audio/vmr-wb": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.3gpp.iufp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.4sb": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.audiokoz": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.celp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cisco.nse": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cmles.radio-events": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cns.anp1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.cns.inf1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dece.audio": {
|
|
source: "iana",
|
|
extensions: ["uva", "uvva"]
|
|
},
|
|
"audio/vnd.digital-winds": {
|
|
source: "iana",
|
|
extensions: ["eol"]
|
|
},
|
|
"audio/vnd.dlna.adts": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.heaac.2": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.mlp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.mps": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2x": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pl2z": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dolby.pulse.1": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dra": {
|
|
source: "iana",
|
|
extensions: ["dra"]
|
|
},
|
|
"audio/vnd.dts": {
|
|
source: "iana",
|
|
extensions: ["dts"]
|
|
},
|
|
"audio/vnd.dts.hd": {
|
|
source: "iana",
|
|
extensions: ["dtshd"]
|
|
},
|
|
"audio/vnd.dts.uhd": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.dvb.file": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.everad.plj": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.hns.audio": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.lucent.voice": {
|
|
source: "iana",
|
|
extensions: ["lvp"]
|
|
},
|
|
"audio/vnd.ms-playready.media.pya": {
|
|
source: "iana",
|
|
extensions: ["pya"]
|
|
},
|
|
"audio/vnd.nokia.mobile-xmf": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.nortel.vbk": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.nuera.ecelp4800": {
|
|
source: "iana",
|
|
extensions: ["ecelp4800"]
|
|
},
|
|
"audio/vnd.nuera.ecelp7470": {
|
|
source: "iana",
|
|
extensions: ["ecelp7470"]
|
|
},
|
|
"audio/vnd.nuera.ecelp9600": {
|
|
source: "iana",
|
|
extensions: ["ecelp9600"]
|
|
},
|
|
"audio/vnd.octel.sbc": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.presonus.multitrack": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.qcelp": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.rhetorex.32kadpcm": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.rip": {
|
|
source: "iana",
|
|
extensions: ["rip"]
|
|
},
|
|
"audio/vnd.rn-realaudio": {
|
|
compressible: false
|
|
},
|
|
"audio/vnd.sealedmedia.softseal.mpeg": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.vmx.cvsd": {
|
|
source: "iana"
|
|
},
|
|
"audio/vnd.wave": {
|
|
compressible: false
|
|
},
|
|
"audio/vorbis": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"audio/vorbis-config": {
|
|
source: "iana"
|
|
},
|
|
"audio/wav": {
|
|
compressible: false,
|
|
extensions: ["wav"]
|
|
},
|
|
"audio/wave": {
|
|
compressible: false,
|
|
extensions: ["wav"]
|
|
},
|
|
"audio/webm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["weba"]
|
|
},
|
|
"audio/x-aac": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["aac"]
|
|
},
|
|
"audio/x-aiff": {
|
|
source: "apache",
|
|
extensions: ["aif", "aiff", "aifc"]
|
|
},
|
|
"audio/x-caf": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["caf"]
|
|
},
|
|
"audio/x-flac": {
|
|
source: "apache",
|
|
extensions: ["flac"]
|
|
},
|
|
"audio/x-m4a": {
|
|
source: "nginx",
|
|
extensions: ["m4a"]
|
|
},
|
|
"audio/x-matroska": {
|
|
source: "apache",
|
|
extensions: ["mka"]
|
|
},
|
|
"audio/x-mpegurl": {
|
|
source: "apache",
|
|
extensions: ["m3u"]
|
|
},
|
|
"audio/x-ms-wax": {
|
|
source: "apache",
|
|
extensions: ["wax"]
|
|
},
|
|
"audio/x-ms-wma": {
|
|
source: "apache",
|
|
extensions: ["wma"]
|
|
},
|
|
"audio/x-pn-realaudio": {
|
|
source: "apache",
|
|
extensions: ["ram", "ra"]
|
|
},
|
|
"audio/x-pn-realaudio-plugin": {
|
|
source: "apache",
|
|
extensions: ["rmp"]
|
|
},
|
|
"audio/x-realaudio": {
|
|
source: "nginx",
|
|
extensions: ["ra"]
|
|
},
|
|
"audio/x-tta": {
|
|
source: "apache"
|
|
},
|
|
"audio/x-wav": {
|
|
source: "apache",
|
|
extensions: ["wav"]
|
|
},
|
|
"audio/xm": {
|
|
source: "apache",
|
|
extensions: ["xm"]
|
|
},
|
|
"chemical/x-cdx": {
|
|
source: "apache",
|
|
extensions: ["cdx"]
|
|
},
|
|
"chemical/x-cif": {
|
|
source: "apache",
|
|
extensions: ["cif"]
|
|
},
|
|
"chemical/x-cmdf": {
|
|
source: "apache",
|
|
extensions: ["cmdf"]
|
|
},
|
|
"chemical/x-cml": {
|
|
source: "apache",
|
|
extensions: ["cml"]
|
|
},
|
|
"chemical/x-csml": {
|
|
source: "apache",
|
|
extensions: ["csml"]
|
|
},
|
|
"chemical/x-pdb": {
|
|
source: "apache"
|
|
},
|
|
"chemical/x-xyz": {
|
|
source: "apache",
|
|
extensions: ["xyz"]
|
|
},
|
|
"font/collection": {
|
|
source: "iana",
|
|
extensions: ["ttc"]
|
|
},
|
|
"font/otf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["otf"]
|
|
},
|
|
"font/sfnt": {
|
|
source: "iana"
|
|
},
|
|
"font/ttf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ttf"]
|
|
},
|
|
"font/woff": {
|
|
source: "iana",
|
|
extensions: ["woff"]
|
|
},
|
|
"font/woff2": {
|
|
source: "iana",
|
|
extensions: ["woff2"]
|
|
},
|
|
"image/aces": {
|
|
source: "iana",
|
|
extensions: ["exr"]
|
|
},
|
|
"image/apng": {
|
|
compressible: false,
|
|
extensions: ["apng"]
|
|
},
|
|
"image/avci": {
|
|
source: "iana",
|
|
extensions: ["avci"]
|
|
},
|
|
"image/avcs": {
|
|
source: "iana",
|
|
extensions: ["avcs"]
|
|
},
|
|
"image/avif": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["avif"]
|
|
},
|
|
"image/bmp": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["bmp"]
|
|
},
|
|
"image/cgm": {
|
|
source: "iana",
|
|
extensions: ["cgm"]
|
|
},
|
|
"image/dicom-rle": {
|
|
source: "iana",
|
|
extensions: ["drle"]
|
|
},
|
|
"image/emf": {
|
|
source: "iana",
|
|
extensions: ["emf"]
|
|
},
|
|
"image/fits": {
|
|
source: "iana",
|
|
extensions: ["fits"]
|
|
},
|
|
"image/g3fax": {
|
|
source: "iana",
|
|
extensions: ["g3"]
|
|
},
|
|
"image/gif": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["gif"]
|
|
},
|
|
"image/heic": {
|
|
source: "iana",
|
|
extensions: ["heic"]
|
|
},
|
|
"image/heic-sequence": {
|
|
source: "iana",
|
|
extensions: ["heics"]
|
|
},
|
|
"image/heif": {
|
|
source: "iana",
|
|
extensions: ["heif"]
|
|
},
|
|
"image/heif-sequence": {
|
|
source: "iana",
|
|
extensions: ["heifs"]
|
|
},
|
|
"image/hej2k": {
|
|
source: "iana",
|
|
extensions: ["hej2"]
|
|
},
|
|
"image/hsj2": {
|
|
source: "iana",
|
|
extensions: ["hsj2"]
|
|
},
|
|
"image/ief": {
|
|
source: "iana",
|
|
extensions: ["ief"]
|
|
},
|
|
"image/jls": {
|
|
source: "iana",
|
|
extensions: ["jls"]
|
|
},
|
|
"image/jp2": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["jp2", "jpg2"]
|
|
},
|
|
"image/jpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["jpeg", "jpg", "jpe"]
|
|
},
|
|
"image/jph": {
|
|
source: "iana",
|
|
extensions: ["jph"]
|
|
},
|
|
"image/jphc": {
|
|
source: "iana",
|
|
extensions: ["jhc"]
|
|
},
|
|
"image/jpm": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["jpm"]
|
|
},
|
|
"image/jpx": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["jpx", "jpf"]
|
|
},
|
|
"image/jxr": {
|
|
source: "iana",
|
|
extensions: ["jxr"]
|
|
},
|
|
"image/jxra": {
|
|
source: "iana",
|
|
extensions: ["jxra"]
|
|
},
|
|
"image/jxrs": {
|
|
source: "iana",
|
|
extensions: ["jxrs"]
|
|
},
|
|
"image/jxs": {
|
|
source: "iana",
|
|
extensions: ["jxs"]
|
|
},
|
|
"image/jxsc": {
|
|
source: "iana",
|
|
extensions: ["jxsc"]
|
|
},
|
|
"image/jxsi": {
|
|
source: "iana",
|
|
extensions: ["jxsi"]
|
|
},
|
|
"image/jxss": {
|
|
source: "iana",
|
|
extensions: ["jxss"]
|
|
},
|
|
"image/ktx": {
|
|
source: "iana",
|
|
extensions: ["ktx"]
|
|
},
|
|
"image/ktx2": {
|
|
source: "iana",
|
|
extensions: ["ktx2"]
|
|
},
|
|
"image/naplps": {
|
|
source: "iana"
|
|
},
|
|
"image/pjpeg": {
|
|
compressible: false
|
|
},
|
|
"image/png": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["png"]
|
|
},
|
|
"image/prs.btif": {
|
|
source: "iana",
|
|
extensions: ["btif"]
|
|
},
|
|
"image/prs.pti": {
|
|
source: "iana",
|
|
extensions: ["pti"]
|
|
},
|
|
"image/pwg-raster": {
|
|
source: "iana"
|
|
},
|
|
"image/sgi": {
|
|
source: "apache",
|
|
extensions: ["sgi"]
|
|
},
|
|
"image/svg+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["svg", "svgz"]
|
|
},
|
|
"image/t38": {
|
|
source: "iana",
|
|
extensions: ["t38"]
|
|
},
|
|
"image/tiff": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["tif", "tiff"]
|
|
},
|
|
"image/tiff-fx": {
|
|
source: "iana",
|
|
extensions: ["tfx"]
|
|
},
|
|
"image/vnd.adobe.photoshop": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["psd"]
|
|
},
|
|
"image/vnd.airzip.accelerator.azv": {
|
|
source: "iana",
|
|
extensions: ["azv"]
|
|
},
|
|
"image/vnd.cns.inf2": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.dece.graphic": {
|
|
source: "iana",
|
|
extensions: ["uvi", "uvvi", "uvg", "uvvg"]
|
|
},
|
|
"image/vnd.djvu": {
|
|
source: "iana",
|
|
extensions: ["djvu", "djv"]
|
|
},
|
|
"image/vnd.dvb.subtitle": {
|
|
source: "iana",
|
|
extensions: ["sub"]
|
|
},
|
|
"image/vnd.dwg": {
|
|
source: "iana",
|
|
extensions: ["dwg"]
|
|
},
|
|
"image/vnd.dxf": {
|
|
source: "iana",
|
|
extensions: ["dxf"]
|
|
},
|
|
"image/vnd.fastbidsheet": {
|
|
source: "iana",
|
|
extensions: ["fbs"]
|
|
},
|
|
"image/vnd.fpx": {
|
|
source: "iana",
|
|
extensions: ["fpx"]
|
|
},
|
|
"image/vnd.fst": {
|
|
source: "iana",
|
|
extensions: ["fst"]
|
|
},
|
|
"image/vnd.fujixerox.edmics-mmr": {
|
|
source: "iana",
|
|
extensions: ["mmr"]
|
|
},
|
|
"image/vnd.fujixerox.edmics-rlc": {
|
|
source: "iana",
|
|
extensions: ["rlc"]
|
|
},
|
|
"image/vnd.globalgraphics.pgb": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.microsoft.icon": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["ico"]
|
|
},
|
|
"image/vnd.mix": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.mozilla.apng": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.ms-dds": {
|
|
compressible: true,
|
|
extensions: ["dds"]
|
|
},
|
|
"image/vnd.ms-modi": {
|
|
source: "iana",
|
|
extensions: ["mdi"]
|
|
},
|
|
"image/vnd.ms-photo": {
|
|
source: "apache",
|
|
extensions: ["wdp"]
|
|
},
|
|
"image/vnd.net-fpx": {
|
|
source: "iana",
|
|
extensions: ["npx"]
|
|
},
|
|
"image/vnd.pco.b16": {
|
|
source: "iana",
|
|
extensions: ["b16"]
|
|
},
|
|
"image/vnd.radiance": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealed.png": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.gif": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.sealedmedia.softseal.jpg": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.svf": {
|
|
source: "iana"
|
|
},
|
|
"image/vnd.tencent.tap": {
|
|
source: "iana",
|
|
extensions: ["tap"]
|
|
},
|
|
"image/vnd.valve.source.texture": {
|
|
source: "iana",
|
|
extensions: ["vtf"]
|
|
},
|
|
"image/vnd.wap.wbmp": {
|
|
source: "iana",
|
|
extensions: ["wbmp"]
|
|
},
|
|
"image/vnd.xiff": {
|
|
source: "iana",
|
|
extensions: ["xif"]
|
|
},
|
|
"image/vnd.zbrush.pcx": {
|
|
source: "iana",
|
|
extensions: ["pcx"]
|
|
},
|
|
"image/webp": {
|
|
source: "apache",
|
|
extensions: ["webp"]
|
|
},
|
|
"image/wmf": {
|
|
source: "iana",
|
|
extensions: ["wmf"]
|
|
},
|
|
"image/x-3ds": {
|
|
source: "apache",
|
|
extensions: ["3ds"]
|
|
},
|
|
"image/x-cmu-raster": {
|
|
source: "apache",
|
|
extensions: ["ras"]
|
|
},
|
|
"image/x-cmx": {
|
|
source: "apache",
|
|
extensions: ["cmx"]
|
|
},
|
|
"image/x-freehand": {
|
|
source: "apache",
|
|
extensions: ["fh", "fhc", "fh4", "fh5", "fh7"]
|
|
},
|
|
"image/x-icon": {
|
|
source: "apache",
|
|
compressible: true,
|
|
extensions: ["ico"]
|
|
},
|
|
"image/x-jng": {
|
|
source: "nginx",
|
|
extensions: ["jng"]
|
|
},
|
|
"image/x-mrsid-image": {
|
|
source: "apache",
|
|
extensions: ["sid"]
|
|
},
|
|
"image/x-ms-bmp": {
|
|
source: "nginx",
|
|
compressible: true,
|
|
extensions: ["bmp"]
|
|
},
|
|
"image/x-pcx": {
|
|
source: "apache",
|
|
extensions: ["pcx"]
|
|
},
|
|
"image/x-pict": {
|
|
source: "apache",
|
|
extensions: ["pic", "pct"]
|
|
},
|
|
"image/x-portable-anymap": {
|
|
source: "apache",
|
|
extensions: ["pnm"]
|
|
},
|
|
"image/x-portable-bitmap": {
|
|
source: "apache",
|
|
extensions: ["pbm"]
|
|
},
|
|
"image/x-portable-graymap": {
|
|
source: "apache",
|
|
extensions: ["pgm"]
|
|
},
|
|
"image/x-portable-pixmap": {
|
|
source: "apache",
|
|
extensions: ["ppm"]
|
|
},
|
|
"image/x-rgb": {
|
|
source: "apache",
|
|
extensions: ["rgb"]
|
|
},
|
|
"image/x-tga": {
|
|
source: "apache",
|
|
extensions: ["tga"]
|
|
},
|
|
"image/x-xbitmap": {
|
|
source: "apache",
|
|
extensions: ["xbm"]
|
|
},
|
|
"image/x-xcf": {
|
|
compressible: false
|
|
},
|
|
"image/x-xpixmap": {
|
|
source: "apache",
|
|
extensions: ["xpm"]
|
|
},
|
|
"image/x-xwindowdump": {
|
|
source: "apache",
|
|
extensions: ["xwd"]
|
|
},
|
|
"message/cpim": {
|
|
source: "iana"
|
|
},
|
|
"message/delivery-status": {
|
|
source: "iana"
|
|
},
|
|
"message/disposition-notification": {
|
|
source: "iana",
|
|
extensions: [
|
|
"disposition-notification"
|
|
]
|
|
},
|
|
"message/external-body": {
|
|
source: "iana"
|
|
},
|
|
"message/feedback-report": {
|
|
source: "iana"
|
|
},
|
|
"message/global": {
|
|
source: "iana",
|
|
extensions: ["u8msg"]
|
|
},
|
|
"message/global-delivery-status": {
|
|
source: "iana",
|
|
extensions: ["u8dsn"]
|
|
},
|
|
"message/global-disposition-notification": {
|
|
source: "iana",
|
|
extensions: ["u8mdn"]
|
|
},
|
|
"message/global-headers": {
|
|
source: "iana",
|
|
extensions: ["u8hdr"]
|
|
},
|
|
"message/http": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"message/imdn+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"message/news": {
|
|
source: "iana"
|
|
},
|
|
"message/partial": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"message/rfc822": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["eml", "mime"]
|
|
},
|
|
"message/s-http": {
|
|
source: "iana"
|
|
},
|
|
"message/sip": {
|
|
source: "iana"
|
|
},
|
|
"message/sipfrag": {
|
|
source: "iana"
|
|
},
|
|
"message/tracking-status": {
|
|
source: "iana"
|
|
},
|
|
"message/vnd.si.simp": {
|
|
source: "iana"
|
|
},
|
|
"message/vnd.wfa.wsc": {
|
|
source: "iana",
|
|
extensions: ["wsc"]
|
|
},
|
|
"model/3mf": {
|
|
source: "iana",
|
|
extensions: ["3mf"]
|
|
},
|
|
"model/e57": {
|
|
source: "iana"
|
|
},
|
|
"model/gltf+json": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["gltf"]
|
|
},
|
|
"model/gltf-binary": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["glb"]
|
|
},
|
|
"model/iges": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["igs", "iges"]
|
|
},
|
|
"model/mesh": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["msh", "mesh", "silo"]
|
|
},
|
|
"model/mtl": {
|
|
source: "iana",
|
|
extensions: ["mtl"]
|
|
},
|
|
"model/obj": {
|
|
source: "iana",
|
|
extensions: ["obj"]
|
|
},
|
|
"model/step": {
|
|
source: "iana"
|
|
},
|
|
"model/step+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["stpx"]
|
|
},
|
|
"model/step+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["stpz"]
|
|
},
|
|
"model/step-xml+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["stpxz"]
|
|
},
|
|
"model/stl": {
|
|
source: "iana",
|
|
extensions: ["stl"]
|
|
},
|
|
"model/vnd.collada+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["dae"]
|
|
},
|
|
"model/vnd.dwf": {
|
|
source: "iana",
|
|
extensions: ["dwf"]
|
|
},
|
|
"model/vnd.flatland.3dml": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.gdl": {
|
|
source: "iana",
|
|
extensions: ["gdl"]
|
|
},
|
|
"model/vnd.gs-gdl": {
|
|
source: "apache"
|
|
},
|
|
"model/vnd.gs.gdl": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.gtw": {
|
|
source: "iana",
|
|
extensions: ["gtw"]
|
|
},
|
|
"model/vnd.moml+xml": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"model/vnd.mts": {
|
|
source: "iana",
|
|
extensions: ["mts"]
|
|
},
|
|
"model/vnd.opengex": {
|
|
source: "iana",
|
|
extensions: ["ogex"]
|
|
},
|
|
"model/vnd.parasolid.transmit.binary": {
|
|
source: "iana",
|
|
extensions: ["x_b"]
|
|
},
|
|
"model/vnd.parasolid.transmit.text": {
|
|
source: "iana",
|
|
extensions: ["x_t"]
|
|
},
|
|
"model/vnd.pytha.pyox": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.rosette.annotated-data-model": {
|
|
source: "iana"
|
|
},
|
|
"model/vnd.sap.vds": {
|
|
source: "iana",
|
|
extensions: ["vds"]
|
|
},
|
|
"model/vnd.usdz+zip": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["usdz"]
|
|
},
|
|
"model/vnd.valve.source.compiled-map": {
|
|
source: "iana",
|
|
extensions: ["bsp"]
|
|
},
|
|
"model/vnd.vtu": {
|
|
source: "iana",
|
|
extensions: ["vtu"]
|
|
},
|
|
"model/vrml": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["wrl", "vrml"]
|
|
},
|
|
"model/x3d+binary": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["x3db", "x3dbz"]
|
|
},
|
|
"model/x3d+fastinfoset": {
|
|
source: "iana",
|
|
extensions: ["x3db"]
|
|
},
|
|
"model/x3d+vrml": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["x3dv", "x3dvz"]
|
|
},
|
|
"model/x3d+xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["x3d", "x3dz"]
|
|
},
|
|
"model/x3d-vrml": {
|
|
source: "iana",
|
|
extensions: ["x3dv"]
|
|
},
|
|
"multipart/alternative": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/appledouble": {
|
|
source: "iana"
|
|
},
|
|
"multipart/byteranges": {
|
|
source: "iana"
|
|
},
|
|
"multipart/digest": {
|
|
source: "iana"
|
|
},
|
|
"multipart/encrypted": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/form-data": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/header-set": {
|
|
source: "iana"
|
|
},
|
|
"multipart/mixed": {
|
|
source: "iana"
|
|
},
|
|
"multipart/multilingual": {
|
|
source: "iana"
|
|
},
|
|
"multipart/parallel": {
|
|
source: "iana"
|
|
},
|
|
"multipart/related": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/report": {
|
|
source: "iana"
|
|
},
|
|
"multipart/signed": {
|
|
source: "iana",
|
|
compressible: false
|
|
},
|
|
"multipart/vnd.bint.med-plus": {
|
|
source: "iana"
|
|
},
|
|
"multipart/voice-message": {
|
|
source: "iana"
|
|
},
|
|
"multipart/x-mixed-replace": {
|
|
source: "iana"
|
|
},
|
|
"text/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"text/cache-manifest": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["appcache", "manifest"]
|
|
},
|
|
"text/calendar": {
|
|
source: "iana",
|
|
extensions: ["ics", "ifb"]
|
|
},
|
|
"text/calender": {
|
|
compressible: true
|
|
},
|
|
"text/cmd": {
|
|
compressible: true
|
|
},
|
|
"text/coffeescript": {
|
|
extensions: ["coffee", "litcoffee"]
|
|
},
|
|
"text/cql": {
|
|
source: "iana"
|
|
},
|
|
"text/cql-expression": {
|
|
source: "iana"
|
|
},
|
|
"text/cql-identifier": {
|
|
source: "iana"
|
|
},
|
|
"text/css": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["css"]
|
|
},
|
|
"text/csv": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["csv"]
|
|
},
|
|
"text/csv-schema": {
|
|
source: "iana"
|
|
},
|
|
"text/directory": {
|
|
source: "iana"
|
|
},
|
|
"text/dns": {
|
|
source: "iana"
|
|
},
|
|
"text/ecmascript": {
|
|
source: "iana"
|
|
},
|
|
"text/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"text/enriched": {
|
|
source: "iana"
|
|
},
|
|
"text/fhirpath": {
|
|
source: "iana"
|
|
},
|
|
"text/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"text/fwdred": {
|
|
source: "iana"
|
|
},
|
|
"text/gff3": {
|
|
source: "iana"
|
|
},
|
|
"text/grammar-ref-list": {
|
|
source: "iana"
|
|
},
|
|
"text/html": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["html", "htm", "shtml"]
|
|
},
|
|
"text/jade": {
|
|
extensions: ["jade"]
|
|
},
|
|
"text/javascript": {
|
|
source: "iana",
|
|
compressible: true
|
|
},
|
|
"text/jcr-cnd": {
|
|
source: "iana"
|
|
},
|
|
"text/jsx": {
|
|
compressible: true,
|
|
extensions: ["jsx"]
|
|
},
|
|
"text/less": {
|
|
compressible: true,
|
|
extensions: ["less"]
|
|
},
|
|
"text/markdown": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["markdown", "md"]
|
|
},
|
|
"text/mathml": {
|
|
source: "nginx",
|
|
extensions: ["mml"]
|
|
},
|
|
"text/mdx": {
|
|
compressible: true,
|
|
extensions: ["mdx"]
|
|
},
|
|
"text/mizar": {
|
|
source: "iana"
|
|
},
|
|
"text/n3": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["n3"]
|
|
},
|
|
"text/parameters": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"text/plain": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"]
|
|
},
|
|
"text/provenance-notation": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/prs.fallenstein.rst": {
|
|
source: "iana"
|
|
},
|
|
"text/prs.lines.tag": {
|
|
source: "iana",
|
|
extensions: ["dsc"]
|
|
},
|
|
"text/prs.prop.logic": {
|
|
source: "iana"
|
|
},
|
|
"text/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"text/red": {
|
|
source: "iana"
|
|
},
|
|
"text/rfc822-headers": {
|
|
source: "iana"
|
|
},
|
|
"text/richtext": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rtx"]
|
|
},
|
|
"text/rtf": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["rtf"]
|
|
},
|
|
"text/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"text/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"text/rtx": {
|
|
source: "iana"
|
|
},
|
|
"text/sgml": {
|
|
source: "iana",
|
|
extensions: ["sgml", "sgm"]
|
|
},
|
|
"text/shaclc": {
|
|
source: "iana"
|
|
},
|
|
"text/shex": {
|
|
source: "iana",
|
|
extensions: ["shex"]
|
|
},
|
|
"text/slim": {
|
|
extensions: ["slim", "slm"]
|
|
},
|
|
"text/spdx": {
|
|
source: "iana",
|
|
extensions: ["spdx"]
|
|
},
|
|
"text/strings": {
|
|
source: "iana"
|
|
},
|
|
"text/stylus": {
|
|
extensions: ["stylus", "styl"]
|
|
},
|
|
"text/t140": {
|
|
source: "iana"
|
|
},
|
|
"text/tab-separated-values": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["tsv"]
|
|
},
|
|
"text/troff": {
|
|
source: "iana",
|
|
extensions: ["t", "tr", "roff", "man", "me", "ms"]
|
|
},
|
|
"text/turtle": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: ["ttl"]
|
|
},
|
|
"text/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"text/uri-list": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["uri", "uris", "urls"]
|
|
},
|
|
"text/vcard": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["vcard"]
|
|
},
|
|
"text/vnd.a": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.abc": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.ascii-art": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.curl": {
|
|
source: "iana",
|
|
extensions: ["curl"]
|
|
},
|
|
"text/vnd.curl.dcurl": {
|
|
source: "apache",
|
|
extensions: ["dcurl"]
|
|
},
|
|
"text/vnd.curl.mcurl": {
|
|
source: "apache",
|
|
extensions: ["mcurl"]
|
|
},
|
|
"text/vnd.curl.scurl": {
|
|
source: "apache",
|
|
extensions: ["scurl"]
|
|
},
|
|
"text/vnd.debian.copyright": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.dmclientscript": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.dvb.subtitle": {
|
|
source: "iana",
|
|
extensions: ["sub"]
|
|
},
|
|
"text/vnd.esmertec.theme-descriptor": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.familysearch.gedcom": {
|
|
source: "iana",
|
|
extensions: ["ged"]
|
|
},
|
|
"text/vnd.ficlab.flt": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.fly": {
|
|
source: "iana",
|
|
extensions: ["fly"]
|
|
},
|
|
"text/vnd.fmi.flexstor": {
|
|
source: "iana",
|
|
extensions: ["flx"]
|
|
},
|
|
"text/vnd.gml": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.graphviz": {
|
|
source: "iana",
|
|
extensions: ["gv"]
|
|
},
|
|
"text/vnd.hans": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.hgl": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.in3d.3dml": {
|
|
source: "iana",
|
|
extensions: ["3dml"]
|
|
},
|
|
"text/vnd.in3d.spot": {
|
|
source: "iana",
|
|
extensions: ["spot"]
|
|
},
|
|
"text/vnd.iptc.newsml": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.iptc.nitf": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.latex-z": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.motorola.reflex": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.ms-mediapackage": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.net2phone.commcenter.command": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.radisys.msml-basic-layout": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.senx.warpscript": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.si.uricatalogue": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.sosi": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.sun.j2me.app-descriptor": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
extensions: ["jad"]
|
|
},
|
|
"text/vnd.trolltech.linguist": {
|
|
source: "iana",
|
|
charset: "UTF-8"
|
|
},
|
|
"text/vnd.wap.si": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.wap.sl": {
|
|
source: "iana"
|
|
},
|
|
"text/vnd.wap.wml": {
|
|
source: "iana",
|
|
extensions: ["wml"]
|
|
},
|
|
"text/vnd.wap.wmlscript": {
|
|
source: "iana",
|
|
extensions: ["wmls"]
|
|
},
|
|
"text/vtt": {
|
|
source: "iana",
|
|
charset: "UTF-8",
|
|
compressible: true,
|
|
extensions: ["vtt"]
|
|
},
|
|
"text/x-asm": {
|
|
source: "apache",
|
|
extensions: ["s", "asm"]
|
|
},
|
|
"text/x-c": {
|
|
source: "apache",
|
|
extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"]
|
|
},
|
|
"text/x-component": {
|
|
source: "nginx",
|
|
extensions: ["htc"]
|
|
},
|
|
"text/x-fortran": {
|
|
source: "apache",
|
|
extensions: ["f", "for", "f77", "f90"]
|
|
},
|
|
"text/x-gwt-rpc": {
|
|
compressible: true
|
|
},
|
|
"text/x-handlebars-template": {
|
|
extensions: ["hbs"]
|
|
},
|
|
"text/x-java-source": {
|
|
source: "apache",
|
|
extensions: ["java"]
|
|
},
|
|
"text/x-jquery-tmpl": {
|
|
compressible: true
|
|
},
|
|
"text/x-lua": {
|
|
extensions: ["lua"]
|
|
},
|
|
"text/x-markdown": {
|
|
compressible: true,
|
|
extensions: ["mkd"]
|
|
},
|
|
"text/x-nfo": {
|
|
source: "apache",
|
|
extensions: ["nfo"]
|
|
},
|
|
"text/x-opml": {
|
|
source: "apache",
|
|
extensions: ["opml"]
|
|
},
|
|
"text/x-org": {
|
|
compressible: true,
|
|
extensions: ["org"]
|
|
},
|
|
"text/x-pascal": {
|
|
source: "apache",
|
|
extensions: ["p", "pas"]
|
|
},
|
|
"text/x-processing": {
|
|
compressible: true,
|
|
extensions: ["pde"]
|
|
},
|
|
"text/x-sass": {
|
|
extensions: ["sass"]
|
|
},
|
|
"text/x-scss": {
|
|
extensions: ["scss"]
|
|
},
|
|
"text/x-setext": {
|
|
source: "apache",
|
|
extensions: ["etx"]
|
|
},
|
|
"text/x-sfv": {
|
|
source: "apache",
|
|
extensions: ["sfv"]
|
|
},
|
|
"text/x-suse-ymp": {
|
|
compressible: true,
|
|
extensions: ["ymp"]
|
|
},
|
|
"text/x-uuencode": {
|
|
source: "apache",
|
|
extensions: ["uu"]
|
|
},
|
|
"text/x-vcalendar": {
|
|
source: "apache",
|
|
extensions: ["vcs"]
|
|
},
|
|
"text/x-vcard": {
|
|
source: "apache",
|
|
extensions: ["vcf"]
|
|
},
|
|
"text/xml": {
|
|
source: "iana",
|
|
compressible: true,
|
|
extensions: ["xml"]
|
|
},
|
|
"text/xml-external-parsed-entity": {
|
|
source: "iana"
|
|
},
|
|
"text/yaml": {
|
|
compressible: true,
|
|
extensions: ["yaml", "yml"]
|
|
},
|
|
"video/1d-interleaved-parityfec": {
|
|
source: "iana"
|
|
},
|
|
"video/3gpp": {
|
|
source: "iana",
|
|
extensions: ["3gp", "3gpp"]
|
|
},
|
|
"video/3gpp-tt": {
|
|
source: "iana"
|
|
},
|
|
"video/3gpp2": {
|
|
source: "iana",
|
|
extensions: ["3g2"]
|
|
},
|
|
"video/av1": {
|
|
source: "iana"
|
|
},
|
|
"video/bmpeg": {
|
|
source: "iana"
|
|
},
|
|
"video/bt656": {
|
|
source: "iana"
|
|
},
|
|
"video/celb": {
|
|
source: "iana"
|
|
},
|
|
"video/dv": {
|
|
source: "iana"
|
|
},
|
|
"video/encaprtp": {
|
|
source: "iana"
|
|
},
|
|
"video/ffv1": {
|
|
source: "iana"
|
|
},
|
|
"video/flexfec": {
|
|
source: "iana"
|
|
},
|
|
"video/h261": {
|
|
source: "iana",
|
|
extensions: ["h261"]
|
|
},
|
|
"video/h263": {
|
|
source: "iana",
|
|
extensions: ["h263"]
|
|
},
|
|
"video/h263-1998": {
|
|
source: "iana"
|
|
},
|
|
"video/h263-2000": {
|
|
source: "iana"
|
|
},
|
|
"video/h264": {
|
|
source: "iana",
|
|
extensions: ["h264"]
|
|
},
|
|
"video/h264-rcdo": {
|
|
source: "iana"
|
|
},
|
|
"video/h264-svc": {
|
|
source: "iana"
|
|
},
|
|
"video/h265": {
|
|
source: "iana"
|
|
},
|
|
"video/iso.segment": {
|
|
source: "iana",
|
|
extensions: ["m4s"]
|
|
},
|
|
"video/jpeg": {
|
|
source: "iana",
|
|
extensions: ["jpgv"]
|
|
},
|
|
"video/jpeg2000": {
|
|
source: "iana"
|
|
},
|
|
"video/jpm": {
|
|
source: "apache",
|
|
extensions: ["jpm", "jpgm"]
|
|
},
|
|
"video/jxsv": {
|
|
source: "iana"
|
|
},
|
|
"video/mj2": {
|
|
source: "iana",
|
|
extensions: ["mj2", "mjp2"]
|
|
},
|
|
"video/mp1s": {
|
|
source: "iana"
|
|
},
|
|
"video/mp2p": {
|
|
source: "iana"
|
|
},
|
|
"video/mp2t": {
|
|
source: "iana",
|
|
extensions: ["ts"]
|
|
},
|
|
"video/mp4": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["mp4", "mp4v", "mpg4"]
|
|
},
|
|
"video/mp4v-es": {
|
|
source: "iana"
|
|
},
|
|
"video/mpeg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"]
|
|
},
|
|
"video/mpeg4-generic": {
|
|
source: "iana"
|
|
},
|
|
"video/mpv": {
|
|
source: "iana"
|
|
},
|
|
"video/nv": {
|
|
source: "iana"
|
|
},
|
|
"video/ogg": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["ogv"]
|
|
},
|
|
"video/parityfec": {
|
|
source: "iana"
|
|
},
|
|
"video/pointer": {
|
|
source: "iana"
|
|
},
|
|
"video/quicktime": {
|
|
source: "iana",
|
|
compressible: false,
|
|
extensions: ["qt", "mov"]
|
|
},
|
|
"video/raptorfec": {
|
|
source: "iana"
|
|
},
|
|
"video/raw": {
|
|
source: "iana"
|
|
},
|
|
"video/rtp-enc-aescm128": {
|
|
source: "iana"
|
|
},
|
|
"video/rtploopback": {
|
|
source: "iana"
|
|
},
|
|
"video/rtx": {
|
|
source: "iana"
|
|
},
|
|
"video/scip": {
|
|
source: "iana"
|
|
},
|
|
"video/smpte291": {
|
|
source: "iana"
|
|
},
|
|
"video/smpte292m": {
|
|
source: "iana"
|
|
},
|
|
"video/ulpfec": {
|
|
source: "iana"
|
|
},
|
|
"video/vc1": {
|
|
source: "iana"
|
|
},
|
|
"video/vc2": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.cctv": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dece.hd": {
|
|
source: "iana",
|
|
extensions: ["uvh", "uvvh"]
|
|
},
|
|
"video/vnd.dece.mobile": {
|
|
source: "iana",
|
|
extensions: ["uvm", "uvvm"]
|
|
},
|
|
"video/vnd.dece.mp4": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dece.pd": {
|
|
source: "iana",
|
|
extensions: ["uvp", "uvvp"]
|
|
},
|
|
"video/vnd.dece.sd": {
|
|
source: "iana",
|
|
extensions: ["uvs", "uvvs"]
|
|
},
|
|
"video/vnd.dece.video": {
|
|
source: "iana",
|
|
extensions: ["uvv", "uvvv"]
|
|
},
|
|
"video/vnd.directv.mpeg": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.directv.mpeg-tts": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dlna.mpeg-tts": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.dvb.file": {
|
|
source: "iana",
|
|
extensions: ["dvb"]
|
|
},
|
|
"video/vnd.fvt": {
|
|
source: "iana",
|
|
extensions: ["fvt"]
|
|
},
|
|
"video/vnd.hns.video": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-1010": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.1dparityfec-2005": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-1010": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.2dparityfec-2005": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsavc": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.iptvforum.ttsmpeg2": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.motorola.video": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.motorola.videop": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.mpegurl": {
|
|
source: "iana",
|
|
extensions: ["mxu", "m4u"]
|
|
},
|
|
"video/vnd.ms-playready.media.pyv": {
|
|
source: "iana",
|
|
extensions: ["pyv"]
|
|
},
|
|
"video/vnd.nokia.interleaved-multimedia": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.nokia.mp4vr": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.nokia.videovoip": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.objectvideo": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.radgamettools.bink": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.radgamettools.smacker": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg1": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.mpeg4": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealed.swf": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.sealedmedia.softseal.mov": {
|
|
source: "iana"
|
|
},
|
|
"video/vnd.uvvu.mp4": {
|
|
source: "iana",
|
|
extensions: ["uvu", "uvvu"]
|
|
},
|
|
"video/vnd.vivo": {
|
|
source: "iana",
|
|
extensions: ["viv"]
|
|
},
|
|
"video/vnd.youtube.yt": {
|
|
source: "iana"
|
|
},
|
|
"video/vp8": {
|
|
source: "iana"
|
|
},
|
|
"video/vp9": {
|
|
source: "iana"
|
|
},
|
|
"video/webm": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["webm"]
|
|
},
|
|
"video/x-f4v": {
|
|
source: "apache",
|
|
extensions: ["f4v"]
|
|
},
|
|
"video/x-fli": {
|
|
source: "apache",
|
|
extensions: ["fli"]
|
|
},
|
|
"video/x-flv": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["flv"]
|
|
},
|
|
"video/x-m4v": {
|
|
source: "apache",
|
|
extensions: ["m4v"]
|
|
},
|
|
"video/x-matroska": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["mkv", "mk3d", "mks"]
|
|
},
|
|
"video/x-mng": {
|
|
source: "apache",
|
|
extensions: ["mng"]
|
|
},
|
|
"video/x-ms-asf": {
|
|
source: "apache",
|
|
extensions: ["asf", "asx"]
|
|
},
|
|
"video/x-ms-vob": {
|
|
source: "apache",
|
|
extensions: ["vob"]
|
|
},
|
|
"video/x-ms-wm": {
|
|
source: "apache",
|
|
extensions: ["wm"]
|
|
},
|
|
"video/x-ms-wmv": {
|
|
source: "apache",
|
|
compressible: false,
|
|
extensions: ["wmv"]
|
|
},
|
|
"video/x-ms-wmx": {
|
|
source: "apache",
|
|
extensions: ["wmx"]
|
|
},
|
|
"video/x-ms-wvx": {
|
|
source: "apache",
|
|
extensions: ["wvx"]
|
|
},
|
|
"video/x-msvideo": {
|
|
source: "apache",
|
|
extensions: ["avi"]
|
|
},
|
|
"video/x-sgi-movie": {
|
|
source: "apache",
|
|
extensions: ["movie"]
|
|
},
|
|
"video/x-smv": {
|
|
source: "apache",
|
|
extensions: ["smv"]
|
|
},
|
|
"x-conference/x-cooltalk": {
|
|
source: "apache",
|
|
extensions: ["ice"]
|
|
},
|
|
"x-shader/x-fragment": {
|
|
compressible: true
|
|
},
|
|
"x-shader/x-vertex": {
|
|
compressible: true
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/mime-db/index.js
|
|
var require_mime_db = __commonJS((exports, module) => {
|
|
/*!
|
|
* mime-db
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2015-2022 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
module.exports = require_db();
|
|
});
|
|
|
|
// node_modules/mime-types/index.js
|
|
var require_mime_types = __commonJS((exports) => {
|
|
var charset = function(type) {
|
|
if (!type || typeof type !== "string")
|
|
return false;
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type);
|
|
var mime = match && db[match[1].toLowerCase()];
|
|
if (mime && mime.charset)
|
|
return mime.charset;
|
|
if (match && TEXT_TYPE_REGEXP.test(match[1]))
|
|
return "UTF-8";
|
|
return false;
|
|
};
|
|
var contentType = function(str) {
|
|
if (!str || typeof str !== "string")
|
|
return false;
|
|
var mime = str.indexOf("/") === -1 ? exports.lookup(str) : str;
|
|
if (!mime)
|
|
return false;
|
|
if (mime.indexOf("charset") === -1) {
|
|
var charset2 = exports.charset(mime);
|
|
if (charset2)
|
|
mime += "; charset=" + charset2.toLowerCase();
|
|
}
|
|
return mime;
|
|
};
|
|
var extension = function(type) {
|
|
if (!type || typeof type !== "string")
|
|
return false;
|
|
var match = EXTRACT_TYPE_REGEXP.exec(type);
|
|
var exts = match && exports.extensions[match[1].toLowerCase()];
|
|
if (!exts || !exts.length)
|
|
return false;
|
|
return exts[0];
|
|
};
|
|
var lookup = function(path) {
|
|
if (!path || typeof path !== "string")
|
|
return false;
|
|
var extension2 = extname("x." + path).toLowerCase().substr(1);
|
|
if (!extension2)
|
|
return false;
|
|
return exports.types[extension2] || false;
|
|
};
|
|
var populateMaps = function(extensions, types) {
|
|
var preference = ["nginx", "apache", undefined, "iana"];
|
|
Object.keys(db).forEach(function forEachMimeType(type) {
|
|
var mime = db[type];
|
|
var exts = mime.extensions;
|
|
if (!exts || !exts.length)
|
|
return;
|
|
extensions[type] = exts;
|
|
for (var i = 0;i < exts.length; i++) {
|
|
var extension2 = exts[i];
|
|
if (types[extension2]) {
|
|
var from = preference.indexOf(db[types[extension2]].source);
|
|
var to = preference.indexOf(mime.source);
|
|
if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/"))
|
|
continue;
|
|
}
|
|
types[extension2] = type;
|
|
}
|
|
});
|
|
};
|
|
/*!
|
|
* mime-types
|
|
* Copyright(c) 2014 Jonathan Ong
|
|
* Copyright(c) 2015 Douglas Christopher Wilson
|
|
* MIT Licensed
|
|
*/
|
|
var db = require_mime_db();
|
|
var extname = __require("path").extname;
|
|
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
|
|
var TEXT_TYPE_REGEXP = /^text\//i;
|
|
exports.charset = charset;
|
|
exports.charsets = { lookup: charset };
|
|
exports.contentType = contentType;
|
|
exports.extension = extension;
|
|
exports.extensions = Object.create(null);
|
|
exports.lookup = lookup;
|
|
exports.types = Object.create(null);
|
|
populateMaps(exports.extensions, exports.types);
|
|
});
|
|
|
|
// node_modules/asynckit/lib/defer.js
|
|
var require_defer = __commonJS((exports, module) => {
|
|
var defer = function(fn) {
|
|
var nextTick = typeof setImmediate == "function" ? setImmediate : typeof process == "object" && typeof process.nextTick == "function" ? process.nextTick : null;
|
|
if (nextTick)
|
|
nextTick(fn);
|
|
else
|
|
setTimeout(fn, 0);
|
|
};
|
|
module.exports = defer;
|
|
});
|
|
|
|
// node_modules/asynckit/lib/async.js
|
|
var require_async = __commonJS((exports, module) => {
|
|
var async = function(callback) {
|
|
var isAsync = false;
|
|
defer(function() {
|
|
isAsync = true;
|
|
});
|
|
return function async_callback(err, result) {
|
|
if (isAsync)
|
|
callback(err, result);
|
|
else
|
|
defer(function nextTick_callback() {
|
|
callback(err, result);
|
|
});
|
|
};
|
|
};
|
|
var defer = require_defer();
|
|
module.exports = async;
|
|
});
|
|
|
|
// node_modules/asynckit/lib/abort.js
|
|
var require_abort = __commonJS((exports, module) => {
|
|
var abort = function(state) {
|
|
Object.keys(state.jobs).forEach(clean.bind(state));
|
|
state.jobs = {};
|
|
};
|
|
var clean = function(key) {
|
|
if (typeof this.jobs[key] == "function")
|
|
this.jobs[key]();
|
|
};
|
|
module.exports = abort;
|
|
});
|
|
|
|
// node_modules/asynckit/lib/iterate.js
|
|
var require_iterate = __commonJS((exports, module) => {
|
|
var iterate = function(list, iterator, state, callback) {
|
|
var key = state["keyedList"] ? state["keyedList"][state.index] : state.index;
|
|
state.jobs[key] = runJob(iterator, key, list[key], function(error, output) {
|
|
if (!(key in state.jobs))
|
|
return;
|
|
delete state.jobs[key];
|
|
if (error)
|
|
abort(state);
|
|
else
|
|
state.results[key] = output;
|
|
callback(error, state.results);
|
|
});
|
|
};
|
|
var runJob = function(iterator, key, item, callback) {
|
|
var aborter;
|
|
if (iterator.length == 2)
|
|
aborter = iterator(item, async(callback));
|
|
else
|
|
aborter = iterator(item, key, async(callback));
|
|
return aborter;
|
|
};
|
|
var async = require_async();
|
|
var abort = require_abort();
|
|
module.exports = iterate;
|
|
});
|
|
|
|
// node_modules/asynckit/lib/state.js
|
|
var require_state = __commonJS((exports, module) => {
|
|
var state = function(list, sortMethod) {
|
|
var isNamedList = !Array.isArray(list), initState = {
|
|
index: 0,
|
|
keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
|
|
jobs: {},
|
|
results: isNamedList ? {} : [],
|
|
size: isNamedList ? Object.keys(list).length : list.length
|
|
};
|
|
if (sortMethod)
|
|
initState.keyedList.sort(isNamedList ? sortMethod : function(a, b) {
|
|
return sortMethod(list[a], list[b]);
|
|
});
|
|
return initState;
|
|
};
|
|
module.exports = state;
|
|
});
|
|
|
|
// node_modules/asynckit/lib/terminator.js
|
|
var require_terminator = __commonJS((exports, module) => {
|
|
var terminator = function(callback) {
|
|
if (!Object.keys(this.jobs).length)
|
|
return;
|
|
this.index = this.size;
|
|
abort(this);
|
|
async(callback)(null, this.results);
|
|
};
|
|
var abort = require_abort();
|
|
var async = require_async();
|
|
module.exports = terminator;
|
|
});
|
|
|
|
// node_modules/asynckit/parallel.js
|
|
var require_parallel = __commonJS((exports, module) => {
|
|
var parallel = function(list, iterator, callback) {
|
|
var state = initState(list);
|
|
while (state.index < (state["keyedList"] || list).length) {
|
|
iterate(list, iterator, state, function(error, result) {
|
|
if (error) {
|
|
callback(error, result);
|
|
return;
|
|
}
|
|
if (Object.keys(state.jobs).length === 0) {
|
|
callback(null, state.results);
|
|
return;
|
|
}
|
|
});
|
|
state.index++;
|
|
}
|
|
return terminator.bind(state, callback);
|
|
};
|
|
var iterate = require_iterate();
|
|
var initState = require_state();
|
|
var terminator = require_terminator();
|
|
module.exports = parallel;
|
|
});
|
|
|
|
// node_modules/asynckit/serialOrdered.js
|
|
var require_serialOrdered = __commonJS((exports, module) => {
|
|
var serialOrdered = function(list, iterator, sortMethod, callback) {
|
|
var state = initState(list, sortMethod);
|
|
iterate(list, iterator, state, function iteratorHandler(error, result) {
|
|
if (error) {
|
|
callback(error, result);
|
|
return;
|
|
}
|
|
state.index++;
|
|
if (state.index < (state["keyedList"] || list).length) {
|
|
iterate(list, iterator, state, iteratorHandler);
|
|
return;
|
|
}
|
|
callback(null, state.results);
|
|
});
|
|
return terminator.bind(state, callback);
|
|
};
|
|
var ascending = function(a, b) {
|
|
return a < b ? -1 : a > b ? 1 : 0;
|
|
};
|
|
var descending = function(a, b) {
|
|
return -1 * ascending(a, b);
|
|
};
|
|
var iterate = require_iterate();
|
|
var initState = require_state();
|
|
var terminator = require_terminator();
|
|
module.exports = serialOrdered;
|
|
module.exports.ascending = ascending;
|
|
module.exports.descending = descending;
|
|
});
|
|
|
|
// node_modules/asynckit/serial.js
|
|
var require_serial = __commonJS((exports, module) => {
|
|
var serial = function(list, iterator, callback) {
|
|
return serialOrdered(list, iterator, null, callback);
|
|
};
|
|
var serialOrdered = require_serialOrdered();
|
|
module.exports = serial;
|
|
});
|
|
|
|
// node_modules/asynckit/index.js
|
|
var require_asynckit = __commonJS((exports, module) => {
|
|
module.exports = {
|
|
parallel: require_parallel(),
|
|
serial: require_serial(),
|
|
serialOrdered: require_serialOrdered()
|
|
};
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/form-data/lib/populate.js
|
|
var require_populate = __commonJS((exports, module) => {
|
|
module.exports = function(dst, src) {
|
|
Object.keys(src).forEach(function(prop) {
|
|
dst[prop] = dst[prop] || src[prop];
|
|
});
|
|
return dst;
|
|
};
|
|
});
|
|
|
|
// node_modules/@azure/core-http/node_modules/form-data/lib/form_data.js
|
|
var require_form_data = __commonJS((exports, module) => {
|
|
var FormData = function(options) {
|
|
if (!(this instanceof FormData))
|
|
return new FormData(options);
|
|
this._overheadLength = 0;
|
|
this._valueLength = 0;
|
|
this._valuesToMeasure = [];
|
|
CombinedStream.call(this);
|
|
options = options || {};
|
|
for (var option in options)
|
|
this[option] = options[option];
|
|
};
|
|
var CombinedStream = require_combined_stream();
|
|
var util = __require("util");
|
|
var path = __require("path");
|
|
var http = __require("http");
|
|
var https = __require("https");
|
|
var parseUrl = __require("url").parse;
|
|
var fs = __require("fs");
|
|
var Stream = __require("stream").Stream;
|
|
var mime = require_mime_types();
|
|
var asynckit = require_asynckit();
|
|
var populate = require_populate();
|
|
module.exports = FormData;
|
|
util.inherits(FormData, CombinedStream);
|
|
FormData.LINE_BREAK = "\r\n";
|
|
FormData.DEFAULT_CONTENT_TYPE = "application/octet-stream";
|
|
FormData.prototype.append = function(field, value, options) {
|
|
options = options || {};
|
|
if (typeof options == "string")
|
|
options = { filename: options };
|
|
var append = CombinedStream.prototype.append.bind(this);
|
|
if (typeof value == "number")
|
|
value = "" + value;
|
|
if (util.isArray(value)) {
|
|
this._error(new Error("Arrays are not supported."));
|
|
return;
|
|
}
|
|
var header = this._multiPartHeader(field, value, options);
|
|
var footer = this._multiPartFooter();
|
|
append(header);
|
|
append(value);
|
|
append(footer);
|
|
this._trackLength(header, value, options);
|
|
};
|
|
FormData.prototype._trackLength = function(header, value, options) {
|
|
var valueLength = 0;
|
|
if (options.knownLength != null)
|
|
valueLength += +options.knownLength;
|
|
else if (Buffer.isBuffer(value))
|
|
valueLength = value.length;
|
|
else if (typeof value === "string")
|
|
valueLength = Buffer.byteLength(value);
|
|
this._valueLength += valueLength;
|
|
this._overheadLength += Buffer.byteLength(header) + FormData.LINE_BREAK.length;
|
|
if (!value || !value.path && !(value.readable && value.hasOwnProperty("httpVersion")) && !(value instanceof Stream))
|
|
return;
|
|
if (!options.knownLength)
|
|
this._valuesToMeasure.push(value);
|
|
};
|
|
FormData.prototype._lengthRetriever = function(value, callback) {
|
|
if (value.hasOwnProperty("fd"))
|
|
if (value.end != null && value.end != Infinity && value.start != null)
|
|
callback(null, value.end + 1 - (value.start ? value.start : 0));
|
|
else
|
|
fs.stat(value.path, function(err, stat) {
|
|
var fileSize;
|
|
if (err) {
|
|
callback(err);
|
|
return;
|
|
}
|
|
fileSize = stat.size - (value.start ? value.start : 0);
|
|
callback(null, fileSize);
|
|
});
|
|
else if (value.hasOwnProperty("httpVersion"))
|
|
callback(null, +value.headers["content-length"]);
|
|
else if (value.hasOwnProperty("httpModule")) {
|
|
value.on("response", function(response) {
|
|
value.pause();
|
|
callback(null, +response.headers["content-length"]);
|
|
});
|
|
value.resume();
|
|
} else
|
|
callback("Unknown stream");
|
|
};
|
|
FormData.prototype._multiPartHeader = function(field, value, options) {
|
|
if (typeof options.header == "string")
|
|
return options.header;
|
|
var contentDisposition = this._getContentDisposition(value, options);
|
|
var contentType = this._getContentType(value, options);
|
|
var contents = "";
|
|
var headers = {
|
|
"Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
|
|
"Content-Type": [].concat(contentType || [])
|
|
};
|
|
if (typeof options.header == "object")
|
|
populate(headers, options.header);
|
|
var header;
|
|
for (var prop in headers) {
|
|
if (!headers.hasOwnProperty(prop))
|
|
continue;
|
|
header = headers[prop];
|
|
if (header == null)
|
|
continue;
|
|
if (!Array.isArray(header))
|
|
header = [header];
|
|
if (header.length)
|
|
contents += prop + ": " + header.join("; ") + FormData.LINE_BREAK;
|
|
}
|
|
return "--" + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
|
|
};
|
|
FormData.prototype._getContentDisposition = function(value, options) {
|
|
var filename, contentDisposition;
|
|
if (typeof options.filepath === "string")
|
|
filename = path.normalize(options.filepath).replace(/\\/g, "/");
|
|
else if (options.filename || value.name || value.path)
|
|
filename = path.basename(options.filename || value.name || value.path);
|
|
else if (value.readable && value.hasOwnProperty("httpVersion"))
|
|
filename = path.basename(value.client._httpMessage.path || "");
|
|
if (filename)
|
|
contentDisposition = 'filename="' + filename + '"';
|
|
return contentDisposition;
|
|
};
|
|
FormData.prototype._getContentType = function(value, options) {
|
|
var contentType = options.contentType;
|
|
if (!contentType && value.name)
|
|
contentType = mime.lookup(value.name);
|
|
if (!contentType && value.path)
|
|
contentType = mime.lookup(value.path);
|
|
if (!contentType && value.readable && value.hasOwnProperty("httpVersion"))
|
|
contentType = value.headers["content-type"];
|
|
if (!contentType && (options.filepath || options.filename))
|
|
contentType = mime.lookup(options.filepath || options.filename);
|
|
if (!contentType && typeof value == "object")
|
|
contentType = FormData.DEFAULT_CONTENT_TYPE;
|
|
return contentType;
|
|
};
|
|
FormData.prototype._multiPartFooter = function() {
|
|
return function(next) {
|
|
var footer = FormData.LINE_BREAK;
|
|
var lastPart = this._streams.length === 0;
|
|
if (lastPart)
|
|
footer += this._lastBoundary();
|
|
next(footer);
|
|
}.bind(this);
|
|
};
|
|
FormData.prototype._lastBoundary = function() {
|
|
return "--" + this.getBoundary() + "--" + FormData.LINE_BREAK;
|
|
};
|
|
FormData.prototype.getHeaders = function(userHeaders) {
|
|
var header;
|
|
var formHeaders = {
|
|
"content-type": "multipart/form-data; boundary=" + this.getBoundary()
|
|
};
|
|
for (header in userHeaders)
|
|
if (userHeaders.hasOwnProperty(header))
|
|
formHeaders[header.toLowerCase()] = userHeaders[header];
|
|
return formHeaders;
|
|
};
|
|
FormData.prototype.setBoundary = function(boundary) {
|
|
this._boundary = boundary;
|
|
};
|
|
FormData.prototype.getBoundary = function() {
|
|
if (!this._boundary)
|
|
this._generateBoundary();
|
|
return this._boundary;
|
|
};
|
|
FormData.prototype.getBuffer = function() {
|
|
var dataBuffer = new Buffer.alloc(0);
|
|
var boundary = this.getBoundary();
|
|
for (var i = 0, len = this._streams.length;i < len; i++)
|
|
if (typeof this._streams[i] !== "function") {
|
|
if (Buffer.isBuffer(this._streams[i]))
|
|
dataBuffer = Buffer.concat([dataBuffer, this._streams[i]]);
|
|
else
|
|
dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i])]);
|
|
if (typeof this._streams[i] !== "string" || this._streams[i].substring(2, boundary.length + 2) !== boundary)
|
|
dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData.LINE_BREAK)]);
|
|
}
|
|
return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
|
|
};
|
|
FormData.prototype._generateBoundary = function() {
|
|
var boundary = "--------------------------";
|
|
for (var i = 0;i < 24; i++)
|
|
boundary += Math.floor(Math.random() * 10).toString(16);
|
|
this._boundary = boundary;
|
|
};
|
|
FormData.prototype.getLengthSync = function() {
|
|
var knownLength = this._overheadLength + this._valueLength;
|
|
if (this._streams.length)
|
|
knownLength += this._lastBoundary().length;
|
|
if (!this.hasKnownLength())
|
|
this._error(new Error("Cannot calculate proper length in synchronous way."));
|
|
return knownLength;
|
|
};
|
|
FormData.prototype.hasKnownLength = function() {
|
|
var hasKnownLength = true;
|
|
if (this._valuesToMeasure.length)
|
|
hasKnownLength = false;
|
|
return hasKnownLength;
|
|
};
|
|
FormData.prototype.getLength = function(cb) {
|
|
var knownLength = this._overheadLength + this._valueLength;
|
|
if (this._streams.length)
|
|
knownLength += this._lastBoundary().length;
|
|
if (!this._valuesToMeasure.length) {
|
|
process.nextTick(cb.bind(this, null, knownLength));
|
|
return;
|
|
}
|
|
asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
|
|
if (err) {
|
|
cb(err);
|
|
return;
|
|
}
|
|
values.forEach(function(length) {
|
|
knownLength += length;
|
|
});
|
|
cb(null, knownLength);
|
|
});
|
|
};
|
|
FormData.prototype.submit = function(params, cb) {
|
|
var request, options, defaults = { method: "post" };
|
|
if (typeof params == "string") {
|
|
params = parseUrl(params);
|
|
options = populate({
|
|
port: params.port,
|
|
path: params.pathname,
|
|
host: params.hostname,
|
|
protocol: params.protocol
|
|
}, defaults);
|
|
} else {
|
|
options = populate(params, defaults);
|
|
if (!options.port)
|
|
options.port = options.protocol == "https:" ? 443 : 80;
|
|
}
|
|
options.headers = this.getHeaders(params.headers);
|
|
if (options.protocol == "https:")
|
|
request = https.request(options);
|
|
else
|
|
request = http.request(options);
|
|
this.getLength(function(err, length) {
|
|
if (err && err !== "Unknown stream") {
|
|
this._error(err);
|
|
return;
|
|
}
|
|
if (length)
|
|
request.setHeader("Content-Length", length);
|
|
this.pipe(request);
|
|
if (cb) {
|
|
var onResponse;
|
|
var callback = function(error, responce) {
|
|
request.removeListener("error", callback);
|
|
request.removeListener("response", onResponse);
|
|
return cb.call(this, error, responce);
|
|
};
|
|
onResponse = callback.bind(this, null);
|
|
request.on("error", callback);
|
|
request.on("response", onResponse);
|
|
}
|
|
}.bind(this));
|
|
return request;
|
|
};
|
|
FormData.prototype._error = function(err) {
|
|
if (!this.error) {
|
|
this.error = err;
|
|
this.pause();
|
|
this.emit("error", err);
|
|
}
|
|
};
|
|
FormData.prototype.toString = function() {
|
|
return "[object FormData]";
|
|
};
|
|
});
|
|
|
|
// node_modules/webidl-conversions/lib/index.js
|
|
var require_lib3 = __commonJS((exports, module) => {
|
|
var sign = function(x) {
|
|
return x < 0 ? -1 : 1;
|
|
};
|
|
var evenRound = function(x) {
|
|
if (x % 1 === 0.5 && (x & 1) === 0)
|
|
return Math.floor(x);
|
|
else
|
|
return Math.round(x);
|
|
};
|
|
var createNumberConversion = function(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)
|
|
return 0;
|
|
}
|
|
return x;
|
|
};
|
|
};
|
|
var conversions = {};
|
|
module.exports = conversions;
|
|
conversions["void"] = function() {
|
|
return;
|
|
};
|
|
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;
|
|
};
|
|
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 < 55296 || c > 57343)
|
|
U.push(String.fromCodePoint(c));
|
|
else if (56320 <= c && c <= 57343)
|
|
U.push(String.fromCodePoint(65533));
|
|
else if (i === n - 1)
|
|
U.push(String.fromCodePoint(65533));
|
|
else {
|
|
const d = S.charCodeAt(i + 1);
|
|
if (56320 <= d && d <= 57343) {
|
|
const a = c & 1023;
|
|
const b = d & 1023;
|
|
U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b));
|
|
++i;
|
|
} else
|
|
U.push(String.fromCodePoint(65533));
|
|
}
|
|
}
|
|
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;
|
|
return V;
|
|
};
|
|
conversions["RegExp"] = function(V, opts) {
|
|
if (!(V instanceof RegExp))
|
|
V = new RegExp(V);
|
|
return V;
|
|
};
|
|
});
|
|
|
|
// node_modules/whatwg-url/lib/utils.js
|
|
var require_utils2 = __commonJS((exports, module) => {
|
|
exports.mixin = function mixin(target, source) {
|
|
const keys = Object.getOwnPropertyNames(source);
|
|
for (let i = 0;i < keys.length; ++i)
|
|
Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
|
|
};
|
|
exports.wrapperSymbol = Symbol("wrapper");
|
|
exports.implSymbol = Symbol("impl");
|
|
exports.wrapperForImpl = function(impl) {
|
|
return impl[exports.wrapperSymbol];
|
|
};
|
|
exports.implForWrapper = function(wrapper) {
|
|
return wrapper[exports.implSymbol];
|
|
};
|
|
});
|
|
|
|
// node_modules/tr46/lib/mappingTable.json
|
|
var require_mappingTable = __commonJS((exports, module) => {
|
|
module.exports = [[[0, 44], "disallowed_STD3_valid"], [[45, 46], "valid"], [[47, 47], "disallowed_STD3_valid"], [[48, 57], "valid"], [[58, 64], "disallowed_STD3_valid"], [[65, 65], "mapped", [97]], [[66, 66], "mapped", [98]], [[67, 67], "mapped", [99]], [[68, 68], "mapped", [100]], [[69, 69], "mapped", [101]], [[70, 70], "mapped", [102]], [[71, 71], "mapped", [103]], [[72, 72], "mapped", [104]], [[73, 73], "mapped", [105]], [[74, 74], "mapped", [106]], [[75, 75], "mapped", [107]], [[76, 76], "mapped", [108]], [[77, 77], "mapped", [109]], [[78, 78], "mapped", [110]], [[79, 79], "mapped", [111]], [[80, 80], "mapped", [112]], [[81, 81], "mapped", [113]], [[82, 82], "mapped", [114]], [[83, 83], "mapped", [115]], [[84, 84], "mapped", [116]], [[85, 85], "mapped", [117]], [[86, 86], "mapped", [118]], [[87, 87], "mapped", [119]], [[88, 88], "mapped", [120]], [[89, 89], "mapped", [121]], [[90, 90], "mapped", [122]], [[91, 96], "disallowed_STD3_valid"], [[97, 122], "valid"], [[123, 127], "disallowed_STD3_valid"], [[128, 159], "disallowed"], [[160, 160], "disallowed_STD3_mapped", [32]], [[161, 167], "valid", [], "NV8"], [[168, 168], "disallowed_STD3_mapped", [32, 776]], [[169, 169], "valid", [], "NV8"], [[170, 170], "mapped", [97]], [[171, 172], "valid", [], "NV8"], [[173, 173], "ignored"], [[174, 174], "valid", [], "NV8"], [[175, 175], "disallowed_STD3_mapped", [32, 772]], [[176, 177], "valid", [], "NV8"], [[178, 178], "mapped", [50]], [[179, 179], "mapped", [51]], [[180, 180], "disallowed_STD3_mapped", [32, 769]], [[181, 181], "mapped", [956]], [[182, 182], "valid", [], "NV8"], [[183, 183], "valid"], [[184, 184], "disallowed_STD3_mapped", [32, 807]], [[185, 185], "mapped", [49]], [[186, 186], "mapped", [111]], [[187, 187], "valid", [], "NV8"], [[188, 188], "mapped", [49, 8260, 52]], [[189, 189], "mapped", [49, 8260, 50]], [[190, 190], "mapped", [51, 8260, 52]], [[191, 191], "valid", [], "NV8"], [[192, 192], "mapped", [224]], [[193, 193], "mapped", [225]], [[194, 194], "mapped", [226]], [[195, 195], "mapped", [227]], [[196, 196], "mapped", [228]], [[197, 197], "mapped", [229]], [[198, 198], "mapped", [230]], [[199, 199], "mapped", [231]], [[200, 200], "mapped", [232]], [[201, 201], "mapped", [233]], [[202, 202], "mapped", [234]], [[203, 203], "mapped", [235]], [[204, 204], "mapped", [236]], [[205, 205], "mapped", [237]], [[206, 206], "mapped", [238]], [[207, 207], "mapped", [239]], [[208, 208], "mapped", [240]], [[209, 209], "mapped", [241]], [[210, 210], "mapped", [242]], [[211, 211], "mapped", [243]], [[212, 212], "mapped", [244]], [[213, 213], "mapped", [245]], [[214, 214], "mapped", [246]], [[215, 215], "valid", [], "NV8"], [[216, 216], "mapped", [248]], [[217, 217], "mapped", [249]], [[218, 218], "mapped", [250]], [[219, 219], "mapped", [251]], [[220, 220], "mapped", [252]], [[221, 221], "mapped", [253]], [[222, 222], "mapped", [254]], [[223, 223], "deviation", [115, 115]], [[224, 246], "valid"], [[247, 247], "valid", [], "NV8"], [[248, 255], "valid"], [[256, 256], "mapped", [257]], [[257, 257], "valid"], [[258, 258], "mapped", [259]], [[259, 259], "valid"], [[260, 260], "mapped", [261]], [[261, 261], "valid"], [[262, 262], "mapped", [263]], [[263, 263], "valid"], [[264, 264], "mapped", [265]], [[265, 265], "valid"], [[266, 266], "mapped", [267]], [[267, 267], "valid"], [[268, 268], "mapped", [269]], [[269, 269], "valid"], [[270, 270], "mapped", [271]], [[271, 271], "valid"], [[272, 272], "mapped", [273]], [[273, 273], "valid"], [[274, 274], "mapped", [275]], [[275, 275], "valid"], [[276, 276], "mapped", [277]], [[277, 277], "valid"], [[278, 278], "mapped", [279]], [[279, 279], "valid"], [[280, 280], "mapped", [281]], [[281, 281], "valid"], [[282, 282], "mapped", [283]], [[283, 283], "valid"], [[284, 284], "mapped", [285]], [[285, 285], "valid"], [[286, 286], "mapped", [287]], [[287, 287], "valid"], [[288, 288], "mapped", [289]], [[289, 289], "valid"], [[290, 290], "mapped", [291]], [[291, 291], "valid"], [[292, 292], "mapped", [293]], [[293, 293], "valid"], [[294, 294], "mapped", [295]], [[295, 295], "valid"], [[296, 296], "mapped", [297]], [[297, 297], "valid"], [[298, 298], "mapped", [299]], [[299, 299], "valid"], [[300, 300], "mapped", [301]], [[301, 301], "valid"], [[302, 302], "mapped", [303]], [[303, 303], "valid"], [[304, 304], "mapped", [105, 775]], [[305, 305], "valid"], [[306, 307], "mapped", [105, 106]], [[308, 308], "mapped", [309]], [[309, 309], "valid"], [[310, 310], "mapped", [311]], [[311, 312], "valid"], [[313, 313], "mapped", [314]], [[314, 314], "valid"], [[315, 315], "mapped", [316]], [[316, 316], "valid"], [[317, 317], "mapped", [318]], [[318, 318], "valid"], [[319, 320], "mapped", [108, 183]], [[321, 321], "mapped", [322]], [[322, 322], "valid"], [[323, 323], "mapped", [324]], [[324, 324], "valid"], [[325, 325], "mapped", [326]], [[326, 326], "valid"], [[327, 327], "mapped", [328]], [[328, 328], "valid"], [[329, 329], "mapped", [700, 110]], [[330, 330], "mapped", [331]], [[331, 331], "valid"], [[332, 332], "mapped", [333]], [[333, 333], "valid"], [[334, 334], "mapped", [335]], [[335, 335], "valid"], [[336, 336], "mapped", [337]], [[337, 337], "valid"], [[338, 338], "mapped", [339]], [[339, 339], "valid"], [[340, 340], "mapped", [341]], [[341, 341], "valid"], [[342, 342], "mapped", [343]], [[343, 343], "valid"], [[344, 344], "mapped", [345]], [[345, 345], "valid"], [[346, 346], "mapped", [347]], [[347, 347], "valid"], [[348, 348], "mapped", [349]], [[349, 349], "valid"], [[350, 350], "mapped", [351]], [[351, 351], "valid"], [[352, 352], "mapped", [353]], [[353, 353], "valid"], [[354, 354], "mapped", [355]], [[355, 355], "valid"], [[356, 356], "mapped", [357]], [[357, 357], "valid"], [[358, 358], "mapped", [359]], [[359, 359], "valid"], [[360, 360], "mapped", [361]], [[361, 361], "valid"], [[362, 362], "mapped", [363]], [[363, 363], "valid"], [[364, 364], "mapped", [365]], [[365, 365], "valid"], [[366, 366], "mapped", [367]], [[367, 367], "valid"], [[368, 368], "mapped", [369]], [[369, 369], "valid"], [[370, 370], "mapped", [371]], [[371, 371], "valid"], [[372, 372], "mapped", [373]], [[373, 373], "valid"], [[374, 374], "mapped", [375]], [[375, 375], "valid"], [[376, 376], "mapped", [255]], [[377, 377], "mapped", [378]], [[378, 378], "valid"], [[379, 379], "mapped", [380]], [[380, 380], "valid"], [[381, 381], "mapped", [382]], [[382, 382], "valid"], [[383, 383], "mapped", [115]], [[384, 384], "valid"], [[385, 385], "mapped", [595]], [[386, 386], "mapped", [387]], [[387, 387], "valid"], [[388, 388], "mapped", [389]], [[389, 389], "valid"], [[390, 390], "mapped", [596]], [[391, 391], "mapped", [392]], [[392, 392], "valid"], [[393, 393], "mapped", [598]], [[394, 394], "mapped", [599]], [[395, 395], "mapped", [396]], [[396, 397], "valid"], [[398, 398], "mapped", [477]], [[399, 399], "mapped", [601]], [[400, 400], "mapped", [603]], [[401, 401], "mapped", [402]], [[402, 402], "valid"], [[403, 403], "mapped", [608]], [[404, 404], "mapped", [611]], [[405, 405], "valid"], [[406, 406], "mapped", [617]], [[407, 407], "mapped", [616]], [[408, 408], "mapped", [409]], [[409, 411], "valid"], [[412, 412], "mapped", [623]], [[413, 413], "mapped", [626]], [[414, 414], "valid"], [[415, 415], "mapped", [629]], [[416, 416], "mapped", [417]], [[417, 417], "valid"], [[418, 418], "mapped", [419]], [[419, 419], "valid"], [[420, 420], "mapped", [421]], [[421, 421], "valid"], [[422, 422], "mapped", [640]], [[423, 423], "mapped", [424]], [[424, 424], "valid"], [[425, 425], "mapped", [643]], [[426, 427], "valid"], [[428, 428], "mapped", [429]], [[429, 429], "valid"], [[430, 430], "mapped", [648]], [[431, 431], "mapped", [432]], [[432, 432], "valid"], [[433, 433], "mapped", [650]], [[434, 434], "mapped", [651]], [[435, 435], "mapped", [436]], [[436, 436], "valid"], [[437, 437], "mapped", [438]], [[438, 438], "valid"], [[439, 439], "mapped", [658]], [[440, 440], "mapped", [441]], [[441, 443], "valid"], [[444, 444], "mapped", [445]], [[445, 451], "valid"], [[452, 454], "mapped", [100, 382]], [[455, 457], "mapped", [108, 106]], [[458, 460], "mapped", [110, 106]], [[461, 461], "mapped", [462]], [[462, 462], "valid"], [[463, 463], "mapped", [464]], [[464, 464], "valid"], [[465, 465], "mapped", [466]], [[466, 466], "valid"], [[467, 467], "mapped", [468]], [[468, 468], "valid"], [[469, 469], "mapped", [470]], [[470, 470], "valid"], [[471, 471], "mapped", [472]], [[472, 472], "valid"], [[473, 473], "mapped", [474]], [[474, 474], "valid"], [[475, 475], "mapped", [476]], [[476, 477], "valid"], [[478, 478], "mapped", [479]], [[479, 479], "valid"], [[480, 480], "mapped", [481]], [[481, 481], "valid"], [[482, 482], "mapped", [483]], [[483, 483], "valid"], [[484, 484], "mapped", [485]], [[485, 485], "valid"], [[486, 486], "mapped", [487]], [[487, 487], "valid"], [[488, 488], "mapped", [489]], [[489, 489], "valid"], [[490, 490], "mapped", [491]], [[491, 491], "valid"], [[492, 492], "mapped", [493]], [[493, 493], "valid"], [[494, 494], "mapped", [495]], [[495, 496], "valid"], [[497, 499], "mapped", [100, 122]], [[500, 500], "mapped", [501]], [[501, 501], "valid"], [[502, 502], "mapped", [405]], [[503, 503], "mapped", [447]], [[504, 504], "mapped", [505]], [[505, 505], "valid"], [[506, 506], "mapped", [507]], [[507, 507], "valid"], [[508, 508], "mapped", [509]], [[509, 509], "valid"], [[510, 510], "mapped", [511]], [[511, 511], "valid"], [[512, 512], "mapped", [513]], [[513, 513], "valid"], [[514, 514], "mapped", [515]], [[515, 515], "valid"], [[516, 516], "mapped", [517]], [[517, 517], "valid"], [[518, 518], "mapped", [519]], [[519, 519], "valid"], [[520, 520], "mapped", [521]], [[521, 521], "valid"], [[522, 522], "mapped", [523]], [[523, 523], "valid"], [[524, 524], "mapped", [525]], [[525, 525], "valid"], [[526, 526], "mapped", [527]], [[527, 527], "valid"], [[528, 528], "mapped", [529]], [[529, 529], "valid"], [[530, 530], "mapped", [531]], [[531, 531], "valid"], [[532, 532], "mapped", [533]], [[533, 533], "valid"], [[534, 534], "mapped", [535]], [[535, 535], "valid"], [[536, 536], "mapped", [537]], [[537, 537], "valid"], [[538, 538], "mapped", [539]], [[539, 539], "valid"], [[540, 540], "mapped", [541]], [[541, 541], "valid"], [[542, 542], "mapped", [543]], [[543, 543], "valid"], [[544, 544], "mapped", [414]], [[545, 545], "valid"], [[546, 546], "mapped", [547]], [[547, 547], "valid"], [[548, 548], "mapped", [549]], [[549, 549], "valid"], [[550, 550], "mapped", [551]], [[551, 551], "valid"], [[552, 552], "mapped", [553]], [[553, 553], "valid"], [[554, 554], "mapped", [555]], [[555, 555], "valid"], [[556, 556], "mapped", [557]], [[557, 557], "valid"], [[558, 558], "mapped", [559]], [[559, 559], "valid"], [[560, 560], "mapped", [561]], [[561, 561], "valid"], [[562, 562], "mapped", [563]], [[563, 563], "valid"], [[564, 566], "valid"], [[567, 569], "valid"], [[570, 570], "mapped", [11365]], [[571, 571], "mapped", [572]], [[572, 572], "valid"], [[573, 573], "mapped", [410]], [[574, 574], "mapped", [11366]], [[575, 576], "valid"], [[577, 577], "mapped", [578]], [[578, 578], "valid"], [[579, 579], "mapped", [384]], [[580, 580], "mapped", [649]], [[581, 581], "mapped", [652]], [[582, 582], "mapped", [583]], [[583, 583], "valid"], [[584, 584], "mapped", [585]], [[585, 585], "valid"], [[586, 586], "mapped", [587]], [[587, 587], "valid"], [[588, 588], "mapped", [589]], [[589, 589], "valid"], [[590, 590], "mapped", [591]], [[591, 591], "valid"], [[592, 680], "valid"], [[681, 685], "valid"], [[686, 687], "valid"], [[688, 688], "mapped", [104]], [[689, 689], "mapped", [614]], [[690, 690], "mapped", [106]], [[691, 691], "mapped", [114]], [[692, 692], "mapped", [633]], [[693, 693], "mapped", [635]], [[694, 694], "mapped", [641]], [[695, 695], "mapped", [119]], [[696, 696], "mapped", [121]], [[697, 705], "valid"], [[706, 709], "valid", [], "NV8"], [[710, 721], "valid"], [[722, 727], "valid", [], "NV8"], [[728, 728], "disallowed_STD3_mapped", [32, 774]], [[729, 729], "disallowed_STD3_mapped", [32, 775]], [[730, 730], "disallowed_STD3_mapped", [32, 778]], [[731, 731], "disallowed_STD3_mapped", [32, 808]], [[732, 732], "disallowed_STD3_mapped", [32, 771]], [[733, 733], "disallowed_STD3_mapped", [32, 779]], [[734, 734], "valid", [], "NV8"], [[735, 735], "valid", [], "NV8"], [[736, 736], "mapped", [611]], [[737, 737], "mapped", [108]], [[738, 738], "mapped", [115]], [[739, 739], "mapped", [120]], [[740, 740], "mapped", [661]], [[741, 745], "valid", [], "NV8"], [[746, 747], "valid", [], "NV8"], [[748, 748], "valid"], [[749, 749], "valid", [], "NV8"], [[750, 750], "valid"], [[751, 767], "valid", [], "NV8"], [[768, 831], "valid"], [[832, 832], "mapped", [768]], [[833, 833], "mapped", [769]], [[834, 834], "valid"], [[835, 835], "mapped", [787]], [[836, 836], "mapped", [776, 769]], [[837, 837], "mapped", [953]], [[838, 846], "valid"], [[847, 847], "ignored"], [[848, 855], "valid"], [[856, 860], "valid"], [[861, 863], "valid"], [[864, 865], "valid"], [[866, 866], "valid"], [[867, 879], "valid"], [[880, 880], "mapped", [881]], [[881, 881], "valid"], [[882, 882], "mapped", [883]], [[883, 883], "valid"], [[884, 884], "mapped", [697]], [[885, 885], "valid"], [[886, 886], "mapped", [887]], [[887, 887], "valid"], [[888, 889], "disallowed"], [[890, 890], "disallowed_STD3_mapped", [32, 953]], [[891, 893], "valid"], [[894, 894], "disallowed_STD3_mapped", [59]], [[895, 895], "mapped", [1011]], [[896, 899], "disallowed"], [[900, 900], "disallowed_STD3_mapped", [32, 769]], [[901, 901], "disallowed_STD3_mapped", [32, 776, 769]], [[902, 902], "mapped", [940]], [[903, 903], "mapped", [183]], [[904, 904], "mapped", [941]], [[905, 905], "mapped", [942]], [[906, 906], "mapped", [943]], [[907, 907], "disallowed"], [[908, 908], "mapped", [972]], [[909, 909], "disallowed"], [[910, 910], "mapped", [973]], [[911, 911], "mapped", [974]], [[912, 912], "valid"], [[913, 913], "mapped", [945]], [[914, 914], "mapped", [946]], [[915, 915], "mapped", [947]], [[916, 916], "mapped", [948]], [[917, 917], "mapped", [949]], [[918, 918], "mapped", [950]], [[919, 919], "mapped", [951]], [[920, 920], "mapped", [952]], [[921, 921], "mapped", [953]], [[922, 922], "mapped", [954]], [[923, 923], "mapped", [955]], [[924, 924], "mapped", [956]], [[925, 925], "mapped", [957]], [[926, 926], "mapped", [958]], [[927, 927], "mapped", [959]], [[928, 928], "mapped", [960]], [[929, 929], "mapped", [961]], [[930, 930], "disallowed"], [[931, 931], "mapped", [963]], [[932, 932], "mapped", [964]], [[933, 933], "mapped", [965]], [[934, 934], "mapped", [966]], [[935, 935], "mapped", [967]], [[936, 936], "mapped", [968]], [[937, 937], "mapped", [969]], [[938, 938], "mapped", [970]], [[939, 939], "mapped", [971]], [[940, 961], "valid"], [[962, 962], "deviation", [963]], [[963, 974], "valid"], [[975, 975], "mapped", [983]], [[976, 976], "mapped", [946]], [[977, 977], "mapped", [952]], [[978, 978], "mapped", [965]], [[979, 979], "mapped", [973]], [[980, 980], "mapped", [971]], [[981, 981], "mapped", [966]], [[982, 982], "mapped", [960]], [[983, 983], "valid"], [[984, 984], "mapped", [985]], [[985, 985], "valid"], [[986, 986], "mapped", [987]], [[987, 987], "valid"], [[988, 988], "mapped", [989]], [[989, 989], "valid"], [[990, 990], "mapped", [991]], [[991, 991], "valid"], [[992, 992], "mapped", [993]], [[993, 993], "valid"], [[994, 994], "mapped", [995]], [[995, 995], "valid"], [[996, 996], "mapped", [997]], [[997, 997], "valid"], [[998, 998], "mapped", [999]], [[999, 999], "valid"], [[1000, 1000], "mapped", [1001]], [[1001, 1001], "valid"], [[1002, 1002], "mapped", [1003]], [[1003, 1003], "valid"], [[1004, 1004], "mapped", [1005]], [[1005, 1005], "valid"], [[1006, 1006], "mapped", [1007]], [[1007, 1007], "valid"], [[1008, 1008], "mapped", [954]], [[1009, 1009], "mapped", [961]], [[1010, 1010], "mapped", [963]], [[1011, 1011], "valid"], [[1012, 1012], "mapped", [952]], [[1013, 1013], "mapped", [949]], [[1014, 1014], "valid", [], "NV8"], [[1015, 1015], "mapped", [1016]], [[1016, 1016], "valid"], [[1017, 1017], "mapped", [963]], [[1018, 1018], "mapped", [1019]], [[1019, 1019], "valid"], [[1020, 1020], "valid"], [[1021, 1021], "mapped", [891]], [[1022, 1022], "mapped", [892]], [[1023, 1023], "mapped", [893]], [[1024, 1024], "mapped", [1104]], [[1025, 1025], "mapped", [1105]], [[1026, 1026], "mapped", [1106]], [[1027, 1027], "mapped", [1107]], [[1028, 1028], "mapped", [1108]], [[1029, 1029], "mapped", [1109]], [[1030, 1030], "mapped", [1110]], [[1031, 1031], "mapped", [1111]], [[1032, 1032], "mapped", [1112]], [[1033, 1033], "mapped", [1113]], [[1034, 1034], "mapped", [1114]], [[1035, 1035], "mapped", [1115]], [[1036, 1036], "mapped", [1116]], [[1037, 1037], "mapped", [1117]], [[1038, 1038], "mapped", [1118]], [[1039, 1039], "mapped", [1119]], [[1040, 1040], "mapped", [1072]], [[1041, 1041], "mapped", [1073]], [[1042, 1042], "mapped", [1074]], [[1043, 1043], "mapped", [1075]], [[1044, 1044], "mapped", [1076]], [[1045, 1045], "mapped", [1077]], [[1046, 1046], "mapped", [1078]], [[1047, 1047], "mapped", [1079]], [[1048, 1048], "mapped", [1080]], [[1049, 1049], "mapped", [1081]], [[1050, 1050], "mapped", [1082]], [[1051, 1051], "mapped", [1083]], [[1052, 1052], "mapped", [1084]], [[1053, 1053], "mapped", [1085]], [[1054, 1054], "mapped", [1086]], [[1055, 1055], "mapped", [1087]], [[1056, 1056], "mapped", [1088]], [[1057, 1057], "mapped", [1089]], [[1058, 1058], "mapped", [1090]], [[1059, 1059], "mapped", [1091]], [[1060, 1060], "mapped", [1092]], [[1061, 1061], "mapped", [1093]], [[1062, 1062], "mapped", [1094]], [[1063, 1063], "mapped", [1095]], [[1064, 1064], "mapped", [1096]], [[1065, 1065], "mapped", [1097]], [[1066, 1066], "mapped", [1098]], [[1067, 1067], "mapped", [1099]], [[1068, 1068], "mapped", [1100]], [[1069, 1069], "mapped", [1101]], [[1070, 1070], "mapped", [1102]], [[1071, 1071], "mapped", [1103]], [[1072, 1103], "valid"], [[1104, 1104], "valid"], [[1105, 1116], "valid"], [[1117, 1117], "valid"], [[1118, 1119], "valid"], [[1120, 1120], "mapped", [1121]], [[1121, 1121], "valid"], [[1122, 1122], "mapped", [1123]], [[1123, 1123], "valid"], [[1124, 1124], "mapped", [1125]], [[1125, 1125], "valid"], [[1126, 1126], "mapped", [1127]], [[1127, 1127], "valid"], [[1128, 1128], "mapped", [1129]], [[1129, 1129], "valid"], [[1130, 1130], "mapped", [1131]], [[1131, 1131], "valid"], [[1132, 1132], "mapped", [1133]], [[1133, 1133], "valid"], [[1134, 1134], "mapped", [1135]], [[1135, 1135], "valid"], [[1136, 1136], "mapped", [1137]], [[1137, 1137], "valid"], [[1138, 1138], "mapped", [1139]], [[1139, 1139], "valid"], [[1140, 1140], "mapped", [1141]], [[1141, 1141], "valid"], [[1142, 1142], "mapped", [1143]], [[1143, 1143], "valid"], [[1144, 1144], "mapped", [1145]], [[1145, 1145], "valid"], [[1146, 1146], "mapped", [1147]], [[1147, 1147], "valid"], [[1148, 1148], "mapped", [1149]], [[1149, 1149], "valid"], [[1150, 1150], "mapped", [1151]], [[1151, 1151], "valid"], [[1152, 1152], "mapped", [1153]], [[1153, 1153], "valid"], [[1154, 1154], "valid", [], "NV8"], [[1155, 1158], "valid"], [[1159, 1159], "valid"], [[1160, 1161], "valid", [], "NV8"], [[1162, 1162], "mapped", [1163]], [[1163, 1163], "valid"], [[1164, 1164], "mapped", [1165]], [[1165, 1165], "valid"], [[1166, 1166], "mapped", [1167]], [[1167, 1167], "valid"], [[1168, 1168], "mapped", [1169]], [[1169, 1169], "valid"], [[1170, 1170], "mapped", [1171]], [[1171, 1171], "valid"], [[1172, 1172], "mapped", [1173]], [[1173, 1173], "valid"], [[1174, 1174], "mapped", [1175]], [[1175, 1175], "valid"], [[1176, 1176], "mapped", [1177]], [[1177, 1177], "valid"], [[1178, 1178], "mapped", [1179]], [[1179, 1179], "valid"], [[1180, 1180], "mapped", [1181]], [[1181, 1181], "valid"], [[1182, 1182], "mapped", [1183]], [[1183, 1183], "valid"], [[1184, 1184], "mapped", [1185]], [[1185, 1185], "valid"], [[1186, 1186], "mapped", [1187]], [[1187, 1187], "valid"], [[1188, 1188], "mapped", [1189]], [[1189, 1189], "valid"], [[1190, 1190], "mapped", [1191]], [[1191, 1191], "valid"], [[1192, 1192], "mapped", [1193]], [[1193, 1193], "valid"], [[1194, 1194], "mapped", [1195]], [[1195, 1195], "valid"], [[1196, 1196], "mapped", [1197]], [[1197, 1197], "valid"], [[1198, 1198], "mapped", [1199]], [[1199, 1199], "valid"], [[1200, 1200], "mapped", [1201]], [[1201, 1201], "valid"], [[1202, 1202], "mapped", [1203]], [[1203, 1203], "valid"], [[1204, 1204], "mapped", [1205]], [[1205, 1205], "valid"], [[1206, 1206], "mapped", [1207]], [[1207, 1207], "valid"], [[1208, 1208], "mapped", [1209]], [[1209, 1209], "valid"], [[1210, 1210], "mapped", [1211]], [[1211, 1211], "valid"], [[1212, 1212], "mapped", [1213]], [[1213, 1213], "valid"], [[1214, 1214], "mapped", [1215]], [[1215, 1215], "valid"], [[1216, 1216], "disallowed"], [[1217, 1217], "mapped", [1218]], [[1218, 1218], "valid"], [[1219, 1219], "mapped", [1220]], [[1220, 1220], "valid"], [[1221, 1221], "mapped", [1222]], [[1222, 1222], "valid"], [[1223, 1223], "mapped", [1224]], [[1224, 1224], "valid"], [[1225, 1225], "mapped", [1226]], [[1226, 1226], "valid"], [[1227, 1227], "mapped", [1228]], [[1228, 1228], "valid"], [[1229, 1229], "mapped", [1230]], [[1230, 1230], "valid"], [[1231, 1231], "valid"], [[1232, 1232], "mapped", [1233]], [[1233, 1233], "valid"], [[1234, 1234], "mapped", [1235]], [[1235, 1235], "valid"], [[1236, 1236], "mapped", [1237]], [[1237, 1237], "valid"], [[1238, 1238], "mapped", [1239]], [[1239, 1239], "valid"], [[1240, 1240], "mapped", [1241]], [[1241, 1241], "valid"], [[1242, 1242], "mapped", [1243]], [[1243, 1243], "valid"], [[1244, 1244], "mapped", [1245]], [[1245, 1245], "valid"], [[1246, 1246], "mapped", [1247]], [[1247, 1247], "valid"], [[1248, 1248], "mapped", [1249]], [[1249, 1249], "valid"], [[1250, 1250], "mapped", [1251]], [[1251, 1251], "valid"], [[1252, 1252], "mapped", [1253]], [[1253, 1253], "valid"], [[1254, 1254], "mapped", [1255]], [[1255, 1255], "valid"], [[1256, 1256], "mapped", [1257]], [[1257, 1257], "valid"], [[1258, 1258], "mapped", [1259]], [[1259, 1259], "valid"], [[1260, 1260], "mapped", [1261]], [[1261, 1261], "valid"], [[1262, 1262], "mapped", [1263]], [[1263, 1263], "valid"], [[1264, 1264], "mapped", [1265]], [[1265, 1265], "valid"], [[1266, 1266], "mapped", [1267]], [[1267, 1267], "valid"], [[1268, 1268], "mapped", [1269]], [[1269, 1269], "valid"], [[1270, 1270], "mapped", [1271]], [[1271, 1271], "valid"], [[1272, 1272], "mapped", [1273]], [[1273, 1273], "valid"], [[1274, 1274], "mapped", [1275]], [[1275, 1275], "valid"], [[1276, 1276], "mapped", [1277]], [[1277, 1277], "valid"], [[1278, 1278], "mapped", [1279]], [[1279, 1279], "valid"], [[1280, 1280], "mapped", [1281]], [[1281, 1281], "valid"], [[1282, 1282], "mapped", [1283]], [[1283, 1283], "valid"], [[1284, 1284], "mapped", [1285]], [[1285, 1285], "valid"], [[1286, 1286], "mapped", [1287]], [[1287, 1287], "valid"], [[1288, 1288], "mapped", [1289]], [[1289, 1289], "valid"], [[1290, 1290], "mapped", [1291]], [[1291, 1291], "valid"], [[1292, 1292], "mapped", [1293]], [[1293, 1293], "valid"], [[1294, 1294], "mapped", [1295]], [[1295, 1295], "valid"], [[1296, 1296], "mapped", [1297]], [[1297, 1297], "valid"], [[1298, 1298], "mapped", [1299]], [[1299, 1299], "valid"], [[1300, 1300], "mapped", [1301]], [[1301, 1301], "valid"], [[1302, 1302], "mapped", [1303]], [[1303, 1303], "valid"], [[1304, 1304], "mapped", [1305]], [[1305, 1305], "valid"], [[1306, 1306], "mapped", [1307]], [[1307, 1307], "valid"], [[1308, 1308], "mapped", [1309]], [[1309, 1309], "valid"], [[1310, 1310], "mapped", [1311]], [[1311, 1311], "valid"], [[1312, 1312], "mapped", [1313]], [[1313, 1313], "valid"], [[1314, 1314], "mapped", [1315]], [[1315, 1315], "valid"], [[1316, 1316], "mapped", [1317]], [[1317, 1317], "valid"], [[1318, 1318], "mapped", [1319]], [[1319, 1319], "valid"], [[1320, 1320], "mapped", [1321]], [[1321, 1321], "valid"], [[1322, 1322], "mapped", [1323]], [[1323, 1323], "valid"], [[1324, 1324], "mapped", [1325]], [[1325, 1325], "valid"], [[1326, 1326], "mapped", [1327]], [[1327, 1327], "valid"], [[1328, 1328], "disallowed"], [[1329, 1329], "mapped", [1377]], [[1330, 1330], "mapped", [1378]], [[1331, 1331], "mapped", [1379]], [[1332, 1332], "mapped", [1380]], [[1333, 1333], "mapped", [1381]], [[1334, 1334], "mapped", [1382]], [[1335, 1335], "mapped", [1383]], [[1336, 1336], "mapped", [1384]], [[1337, 1337], "mapped", [1385]], [[1338, 1338], "mapped", [1386]], [[1339, 1339], "mapped", [1387]], [[1340, 1340], "mapped", [1388]], [[1341, 1341], "mapped", [1389]], [[1342, 1342], "mapped", [1390]], [[1343, 1343], "mapped", [1391]], [[1344, 1344], "mapped", [1392]], [[1345, 1345], "mapped", [1393]], [[1346, 1346], "mapped", [1394]], [[1347, 1347], "mapped", [1395]], [[1348, 1348], "mapped", [1396]], [[1349, 1349], "mapped", [1397]], [[1350, 1350], "mapped", [1398]], [[1351, 1351], "mapped", [1399]], [[1352, 1352], "mapped", [1400]], [[1353, 1353], "mapped", [1401]], [[1354, 1354], "mapped", [1402]], [[1355, 1355], "mapped", [1403]], [[1356, 1356], "mapped", [1404]], [[1357, 1357], "mapped", [1405]], [[1358, 1358], "mapped", [1406]], [[1359, 1359], "mapped", [1407]], [[1360, 1360], "mapped", [1408]], [[1361, 1361], "mapped", [1409]], [[1362, 1362], "mapped", [1410]], [[1363, 1363], "mapped", [1411]], [[1364, 1364], "mapped", [1412]], [[1365, 1365], "mapped", [1413]], [[1366, 1366], "mapped", [1414]], [[1367, 1368], "disallowed"], [[1369, 1369], "valid"], [[1370, 1375], "valid", [], "NV8"], [[1376, 1376], "disallowed"], [[1377, 1414], "valid"], [[1415, 1415], "mapped", [1381, 1410]], [[1416, 1416], "disallowed"], [[1417, 1417], "valid", [], "NV8"], [[1418, 1418], "valid", [], "NV8"], [[1419, 1420], "disallowed"], [[1421, 1422], "valid", [], "NV8"], [[1423, 1423], "valid", [], "NV8"], [[1424, 1424], "disallowed"], [[1425, 1441], "valid"], [[1442, 1442], "valid"], [[1443, 1455], "valid"], [[1456, 1465], "valid"], [[1466, 1466], "valid"], [[1467, 1469], "valid"], [[1470, 1470], "valid", [], "NV8"], [[1471, 1471], "valid"], [[1472, 1472], "valid", [], "NV8"], [[1473, 1474], "valid"], [[1475, 1475], "valid", [], "NV8"], [[1476, 1476], "valid"], [[1477, 1477], "valid"], [[1478, 1478], "valid", [], "NV8"], [[1479, 1479], "valid"], [[1480, 1487], "disallowed"], [[1488, 1514], "valid"], [[1515, 1519], "disallowed"], [[1520, 1524], "valid"], [[1525, 1535], "disallowed"], [[1536, 1539], "disallowed"], [[1540, 1540], "disallowed"], [[1541, 1541], "disallowed"], [[1542, 1546], "valid", [], "NV8"], [[1547, 1547], "valid", [], "NV8"], [[1548, 1548], "valid", [], "NV8"], [[1549, 1551], "valid", [], "NV8"], [[1552, 1557], "valid"], [[1558, 1562], "valid"], [[1563, 1563], "valid", [], "NV8"], [[1564, 1564], "disallowed"], [[1565, 1565], "disallowed"], [[1566, 1566], "valid", [], "NV8"], [[1567, 1567], "valid", [], "NV8"], [[1568, 1568], "valid"], [[1569, 1594], "valid"], [[1595, 1599], "valid"], [[1600, 1600], "valid", [], "NV8"], [[1601, 1618], "valid"], [[1619, 1621], "valid"], [[1622, 1624], "valid"], [[1625, 1630], "valid"], [[1631, 1631], "valid"], [[1632, 1641], "valid"], [[1642, 1645], "valid", [], "NV8"], [[1646, 1647], "valid"], [[1648, 1652], "valid"], [[1653, 1653], "mapped", [1575, 1652]], [[1654, 1654], "mapped", [1608, 1652]], [[1655, 1655], "mapped", [1735, 1652]], [[1656, 1656], "mapped", [1610, 1652]], [[1657, 1719], "valid"], [[1720, 1721], "valid"], [[1722, 1726], "valid"], [[1727, 1727], "valid"], [[1728, 1742], "valid"], [[1743, 1743], "valid"], [[1744, 1747], "valid"], [[1748, 1748], "valid", [], "NV8"], [[1749, 1756], "valid"], [[1757, 1757], "disallowed"], [[1758, 1758], "valid", [], "NV8"], [[1759, 1768], "valid"], [[1769, 1769], "valid", [], "NV8"], [[1770, 1773], "valid"], [[1774, 1775], "valid"], [[1776, 1785], "valid"], [[1786, 1790], "valid"], [[1791, 1791], "valid"], [[1792, 1805], "valid", [], "NV8"], [[1806, 1806], "disallowed"], [[1807, 1807], "disallowed"], [[1808, 1836], "valid"], [[1837, 1839], "valid"], [[1840, 1866], "valid"], [[1867, 1868], "disallowed"], [[1869, 1871], "valid"], [[1872, 1901], "valid"], [[1902, 1919], "valid"], [[1920, 1968], "valid"], [[1969, 1969], "valid"], [[1970, 1983], "disallowed"], [[1984, 2037], "valid"], [[2038, 2042], "valid", [], "NV8"], [[2043, 2047], "disallowed"], [[2048, 2093], "valid"], [[2094, 2095], "disallowed"], [[2096, 2110], "valid", [], "NV8"], [[2111, 2111], "disallowed"], [[2112, 2139], "valid"], [[2140, 2141], "disallowed"], [[2142, 2142], "valid", [], "NV8"], [[2143, 2207], "disallowed"], [[2208, 2208], "valid"], [[2209, 2209], "valid"], [[2210, 2220], "valid"], [[2221, 2226], "valid"], [[2227, 2228], "valid"], [[2229, 2274], "disallowed"], [[2275, 2275], "valid"], [[2276, 2302], "valid"], [[2303, 2303], "valid"], [[2304, 2304], "valid"], [[2305, 2307], "valid"], [[2308, 2308], "valid"], [[2309, 2361], "valid"], [[2362, 2363], "valid"], [[2364, 2381], "valid"], [[2382, 2382], "valid"], [[2383, 2383], "valid"], [[2384, 2388], "valid"], [[2389, 2389], "valid"], [[2390, 2391], "valid"], [[2392, 2392], "mapped", [2325, 2364]], [[2393, 2393], "mapped", [2326, 2364]], [[2394, 2394], "mapped", [2327, 2364]], [[2395, 2395], "mapped", [2332, 2364]], [[2396, 2396], "mapped", [2337, 2364]], [[2397, 2397], "mapped", [2338, 2364]], [[2398, 2398], "mapped", [2347, 2364]], [[2399, 2399], "mapped", [2351, 2364]], [[2400, 2403], "valid"], [[2404, 2405], "valid", [], "NV8"], [[2406, 2415], "valid"], [[2416, 2416], "valid", [], "NV8"], [[2417, 2418], "valid"], [[2419, 2423], "valid"], [[2424, 2424], "valid"], [[2425, 2426], "valid"], [[2427, 2428], "valid"], [[2429, 2429], "valid"], [[2430, 2431], "valid"], [[2432, 2432], "valid"], [[2433, 2435], "valid"], [[2436, 2436], "disallowed"], [[2437, 2444], "valid"], [[2445, 2446], "disallowed"], [[2447, 2448], "valid"], [[2449, 2450], "disallowed"], [[2451, 2472], "valid"], [[2473, 2473], "disallowed"], [[2474, 2480], "valid"], [[2481, 2481], "disallowed"], [[2482, 2482], "valid"], [[2483, 2485], "disallowed"], [[2486, 2489], "valid"], [[2490, 2491], "disallowed"], [[2492, 2492], "valid"], [[2493, 2493], "valid"], [[2494, 2500], "valid"], [[2501, 2502], "disallowed"], [[2503, 2504], "valid"], [[2505, 2506], "disallowed"], [[2507, 2509], "valid"], [[2510, 2510], "valid"], [[2511, 2518], "disallowed"], [[2519, 2519], "valid"], [[2520, 2523], "disallowed"], [[2524, 2524], "mapped", [2465, 2492]], [[2525, 2525], "mapped", [2466, 2492]], [[2526, 2526], "disallowed"], [[2527, 2527], "mapped", [2479, 2492]], [[2528, 2531], "valid"], [[2532, 2533], "disallowed"], [[2534, 2545], "valid"], [[2546, 2554], "valid", [], "NV8"], [[2555, 2555], "valid", [], "NV8"], [[2556, 2560], "disallowed"], [[2561, 2561], "valid"], [[2562, 2562], "valid"], [[2563, 2563], "valid"], [[2564, 2564], "disallowed"], [[2565, 2570], "valid"], [[2571, 2574], "disallowed"], [[2575, 2576], "valid"], [[2577, 2578], "disallowed"], [[2579, 2600], "valid"], [[2601, 2601], "disallowed"], [[2602, 2608], "valid"], [[2609, 2609], "disallowed"], [[2610, 2610], "valid"], [[2611, 2611], "mapped", [2610, 2620]], [[2612, 2612], "disallowed"], [[2613, 2613], "valid"], [[2614, 2614], "mapped", [2616, 2620]], [[2615, 2615], "disallowed"], [[2616, 2617], "valid"], [[2618, 2619], "disallowed"], [[2620, 2620], "valid"], [[2621, 2621], "disallowed"], [[2622, 2626], "valid"], [[2627, 2630], "disallowed"], [[2631, 2632], "valid"], [[2633, 2634], "disallowed"], [[2635, 2637], "valid"], [[2638, 2640], "disallowed"], [[2641, 2641], "valid"], [[2642, 2648], "disallowed"], [[2649, 2649], "mapped", [2582, 2620]], [[2650, 2650], "mapped", [2583, 2620]], [[2651, 2651], "mapped", [2588, 2620]], [[2652, 2652], "valid"], [[2653, 2653], "disallowed"], [[2654, 2654], "mapped", [2603, 2620]], [[2655, 2661], "disallowed"], [[2662, 2676], "valid"], [[2677, 2677], "valid"], [[2678, 2688], "disallowed"], [[2689, 2691], "valid"], [[2692, 2692], "disallowed"], [[2693, 2699], "valid"], [[2700, 2700], "valid"], [[2701, 2701], "valid"], [[2702, 2702], "disallowed"], [[2703, 2705], "valid"], [[2706, 2706], "disallowed"], [[2707, 2728], "valid"], [[2729, 2729], "disallowed"], [[2730, 2736], "valid"], [[2737, 2737], "disallowed"], [[2738, 2739], "valid"], [[2740, 2740], "disallowed"], [[2741, 2745], "valid"], [[2746, 2747], "disallowed"], [[2748, 2757], "valid"], [[2758, 2758], "disallowed"], [[2759, 2761], "valid"], [[2762, 2762], "disallowed"], [[2763, 2765], "valid"], [[2766, 2767], "disallowed"], [[2768, 2768], "valid"], [[2769, 2783], "disallowed"], [[2784, 2784], "valid"], [[2785, 2787], "valid"], [[2788, 2789], "disallowed"], [[2790, 2799], "valid"], [[2800, 2800], "valid", [], "NV8"], [[2801, 2801], "valid", [], "NV8"], [[2802, 2808], "disallowed"], [[2809, 2809], "valid"], [[2810, 2816], "disallowed"], [[2817, 2819], "valid"], [[2820, 2820], "disallowed"], [[2821, 2828], "valid"], [[2829, 2830], "disallowed"], [[2831, 2832], "valid"], [[2833, 2834], "disallowed"], [[2835, 2856], "valid"], [[2857, 2857], "disallowed"], [[2858, 2864], "valid"], [[2865, 2865], "disallowed"], [[2866, 2867], "valid"], [[2868, 2868], "disallowed"], [[2869, 2869], "valid"], [[2870, 2873], "valid"], [[2874, 2875], "disallowed"], [[2876, 2883], "valid"], [[2884, 2884], "valid"], [[2885, 2886], "disallowed"], [[2887, 2888], "valid"], [[2889, 2890], "disallowed"], [[2891, 2893], "valid"], [[2894, 2901], "disallowed"], [[2902, 2903], "valid"], [[2904, 2907], "disallowed"], [[2908, 2908], "mapped", [2849, 2876]], [[2909, 2909], "mapped", [2850, 2876]], [[2910, 2910], "disallowed"], [[2911, 2913], "valid"], [[2914, 2915], "valid"], [[2916, 2917], "disallowed"], [[2918, 2927], "valid"], [[2928, 2928], "valid", [], "NV8"], [[2929, 2929], "valid"], [[2930, 2935], "valid", [], "NV8"], [[2936, 2945], "disallowed"], [[2946, 2947], "valid"], [[2948, 2948], "disallowed"], [[2949, 2954], "valid"], [[2955, 2957], "disallowed"], [[2958, 2960], "valid"], [[2961, 2961], "disallowed"], [[2962, 2965], "valid"], [[2966, 2968], "disallowed"], [[2969, 2970], "valid"], [[2971, 2971], "disallowed"], [[2972, 2972], "valid"], [[2973, 2973], "disallowed"], [[2974, 2975], "valid"], [[2976, 2978], "disallowed"], [[2979, 2980], "valid"], [[2981, 2983], "disallowed"], [[2984, 2986], "valid"], [[2987, 2989], "disallowed"], [[2990, 2997], "valid"], [[2998, 2998], "valid"], [[2999, 3001], "valid"], [[3002, 3005], "disallowed"], [[3006, 3010], "valid"], [[3011, 3013], "disallowed"], [[3014, 3016], "valid"], [[3017, 3017], "disallowed"], [[3018, 3021], "valid"], [[3022, 3023], "disallowed"], [[3024, 3024], "valid"], [[3025, 3030], "disallowed"], [[3031, 3031], "valid"], [[3032, 3045], "disallowed"], [[3046, 3046], "valid"], [[3047, 3055], "valid"], [[3056, 3058], "valid", [], "NV8"], [[3059, 3066], "valid", [], "NV8"], [[3067, 3071], "disallowed"], [[3072, 3072], "valid"], [[3073, 3075], "valid"], [[3076, 3076], "disallowed"], [[3077, 3084], "valid"], [[3085, 3085], "disallowed"], [[3086, 3088], "valid"], [[3089, 3089], "disallowed"], [[3090, 3112], "valid"], [[3113, 3113], "disallowed"], [[3114, 3123], "valid"], [[3124, 3124], "valid"], [[3125, 3129], "valid"], [[3130, 3132], "disallowed"], [[3133, 3133], "valid"], [[3134, 3140], "valid"], [[3141, 3141], "disallowed"], [[3142, 3144], "valid"], [[3145, 3145], "disallowed"], [[3146, 3149], "valid"], [[3150, 3156], "disallowed"], [[3157, 3158], "valid"], [[3159, 3159], "disallowed"], [[3160, 3161], "valid"], [[3162, 3162], "valid"], [[3163, 3167], "disallowed"], [[3168, 3169], "valid"], [[3170, 3171], "valid"], [[3172, 3173], "disallowed"], [[3174, 3183], "valid"], [[3184, 3191], "disallowed"], [[3192, 3199], "valid", [], "NV8"], [[3200, 3200], "disallowed"], [[3201, 3201], "valid"], [[3202, 3203], "valid"], [[3204, 3204], "disallowed"], [[3205, 3212], "valid"], [[3213, 3213], "disallowed"], [[3214, 3216], "valid"], [[3217, 3217], "disallowed"], [[3218, 3240], "valid"], [[3241, 3241], "disallowed"], [[3242, 3251], "valid"], [[3252, 3252], "disallowed"], [[3253, 3257], "valid"], [[3258, 3259], "disallowed"], [[3260, 3261], "valid"], [[3262, 3268], "valid"], [[3269, 3269], "disallowed"], [[3270, 3272], "valid"], [[3273, 3273], "disallowed"], [[3274, 3277], "valid"], [[3278, 3284], "disallowed"], [[3285, 3286], "valid"], [[3287, 3293], "disallowed"], [[3294, 3294], "valid"], [[3295, 3295], "disallowed"], [[3296, 3297], "valid"], [[3298, 3299], "valid"], [[3300, 3301], "disallowed"], [[3302, 3311], "valid"], [[3312, 3312], "disallowed"], [[3313, 3314], "valid"], [[3315, 3328], "disallowed"], [[3329, 3329], "valid"], [[3330, 3331], "valid"], [[3332, 3332], "disallowed"], [[3333, 3340], "valid"], [[3341, 3341], "disallowed"], [[3342, 3344], "valid"], [[3345, 3345], "disallowed"], [[3346, 3368], "valid"], [[3369, 3369], "valid"], [[3370, 3385], "valid"], [[3386, 3386], "valid"], [[3387, 3388], "disallowed"], [[3389, 3389], "valid"], [[3390, 3395], "valid"], [[3396, 3396], "valid"], [[3397, 3397], "disallowed"], [[3398, 3400], "valid"], [[3401, 3401], "disallowed"], [[3402, 3405], "valid"], [[3406, 3406], "valid"], [[3407, 3414], "disallowed"], [[3415, 3415], "valid"], [[3416, 3422], "disallowed"], [[3423, 3423], "valid"], [[3424, 3425], "valid"], [[3426, 3427], "valid"], [[3428, 3429], "disallowed"], [[3430, 3439], "valid"], [[3440, 3445], "valid", [], "NV8"], [[3446, 3448], "disallowed"], [[3449, 3449], "valid", [], "NV8"], [[3450, 3455], "valid"], [[3456, 3457], "disallowed"], [[3458, 3459], "valid"], [[3460, 3460], "disallowed"], [[3461, 3478], "valid"], [[3479, 3481], "disallowed"], [[3482, 3505], "valid"], [[3506, 3506], "disallowed"], [[3507, 3515], "valid"], [[3516, 3516], "disallowed"], [[3517, 3517], "valid"], [[3518, 3519], "disallowed"], [[3520, 3526], "valid"], [[3527, 3529], "disallowed"], [[3530, 3530], "valid"], [[3531, 3534], "disallowed"], [[3535, 3540], "valid"], [[3541, 3541], "disallowed"], [[3542, 3542], "valid"], [[3543, 3543], "disallowed"], [[3544, 3551], "valid"], [[3552, 3557], "disallowed"], [[3558, 3567], "valid"], [[3568, 3569], "disallowed"], [[3570, 3571], "valid"], [[3572, 3572], "valid", [], "NV8"], [[3573, 3584], "disallowed"], [[3585, 3634], "valid"], [[3635, 3635], "mapped", [3661, 3634]], [[3636, 3642], "valid"], [[3643, 3646], "disallowed"], [[3647, 3647], "valid", [], "NV8"], [[3648, 3662], "valid"], [[3663, 3663], "valid", [], "NV8"], [[3664, 3673], "valid"], [[3674, 3675], "valid", [], "NV8"], [[3676, 3712], "disallowed"], [[3713, 3714], "valid"], [[3715, 3715], "disallowed"], [[3716, 3716], "valid"], [[3717, 3718], "disallowed"], [[3719, 3720], "valid"], [[3721, 3721], "disallowed"], [[3722, 3722], "valid"], [[3723, 3724], "disallowed"], [[3725, 3725], "valid"], [[3726, 3731], "disallowed"], [[3732, 3735], "valid"], [[3736, 3736], "disallowed"], [[3737, 3743], "valid"], [[3744, 3744], "disallowed"], [[3745, 3747], "valid"], [[3748, 3748], "disallowed"], [[3749, 3749], "valid"], [[3750, 3750], "disallowed"], [[3751, 3751], "valid"], [[3752, 3753], "disallowed"], [[3754, 3755], "valid"], [[3756, 3756], "disallowed"], [[3757, 3762], "valid"], [[3763, 3763], "mapped", [3789, 3762]], [[3764, 3769], "valid"], [[3770, 3770], "disallowed"], [[3771, 3773], "valid"], [[3774, 3775], "disallowed"], [[3776, 3780], "valid"], [[3781, 3781], "disallowed"], [[3782, 3782], "valid"], [[3783, 3783], "disallowed"], [[3784, 3789], "valid"], [[3790, 3791], "disallowed"], [[3792, 3801], "valid"], [[3802, 3803], "disallowed"], [[3804, 3804], "mapped", [3755, 3737]], [[3805, 3805], "mapped", [3755, 3745]], [[3806, 3807], "valid"], [[3808, 3839], "disallowed"], [[3840, 3840], "valid"], [[3841, 3850], "valid", [], "NV8"], [[3851, 3851], "valid"], [[3852, 3852], "mapped", [3851]], [[3853, 3863], "valid", [], "NV8"], [[3864, 3865], "valid"], [[3866, 3871], "valid", [], "NV8"], [[3872, 3881], "valid"], [[3882, 3892], "valid", [], "NV8"], [[3893, 3893], "valid"], [[3894, 3894], "valid", [], "NV8"], [[3895, 3895], "valid"], [[3896, 3896], "valid", [], "NV8"], [[3897, 3897], "valid"], [[3898, 3901], "valid", [], "NV8"], [[3902, 3906], "valid"], [[3907, 3907], "mapped", [3906, 4023]], [[3908, 3911], "valid"], [[3912, 3912], "disallowed"], [[3913, 3916], "valid"], [[3917, 3917], "mapped", [3916, 4023]], [[3918, 3921], "valid"], [[3922, 3922], "mapped", [3921, 4023]], [[3923, 3926], "valid"], [[3927, 3927], "mapped", [3926, 4023]], [[3928, 3931], "valid"], [[3932, 3932], "mapped", [3931, 4023]], [[3933, 3944], "valid"], [[3945, 3945], "mapped", [3904, 4021]], [[3946, 3946], "valid"], [[3947, 3948], "valid"], [[3949, 3952], "disallowed"], [[3953, 3954], "valid"], [[3955, 3955], "mapped", [3953, 3954]], [[3956, 3956], "valid"], [[3957, 3957], "mapped", [3953, 3956]], [[3958, 3958], "mapped", [4018, 3968]], [[3959, 3959], "mapped", [4018, 3953, 3968]], [[3960, 3960], "mapped", [4019, 3968]], [[3961, 3961], "mapped", [4019, 3953, 3968]], [[3962, 3968], "valid"], [[3969, 3969], "mapped", [3953, 3968]], [[3970, 3972], "valid"], [[3973, 3973], "valid", [], "NV8"], [[3974, 3979], "valid"], [[3980, 3983], "valid"], [[3984, 3986], "valid"], [[3987, 3987], "mapped", [3986, 4023]], [[3988, 3989], "valid"], [[3990, 3990], "valid"], [[3991, 3991], "valid"], [[3992, 3992], "disallowed"], [[3993, 3996], "valid"], [[3997, 3997], "mapped", [3996, 4023]], [[3998, 4001], "valid"], [[4002, 4002], "mapped", [4001, 4023]], [[4003, 4006], "valid"], [[4007, 4007], "mapped", [4006, 4023]], [[4008, 4011], "valid"], [[4012, 4012], "mapped", [4011, 4023]], [[4013, 4013], "valid"], [[4014, 4016], "valid"], [[4017, 4023], "valid"], [[4024, 4024], "valid"], [[4025, 4025], "mapped", [3984, 4021]], [[4026, 4028], "valid"], [[4029, 4029], "disallowed"], [[4030, 4037], "valid", [], "NV8"], [[4038, 4038], "valid"], [[4039, 4044], "valid", [], "NV8"], [[4045, 4045], "disallowed"], [[4046, 4046], "valid", [], "NV8"], [[4047, 4047], "valid", [], "NV8"], [[4048, 4049], "valid", [], "NV8"], [[4050, 4052], "valid", [], "NV8"], [[4053, 4056], "valid", [], "NV8"], [[4057, 4058], "valid", [], "NV8"], [[4059, 4095], "disallowed"], [[4096, 4129], "valid"], [[4130, 4130], "valid"], [[4131, 4135], "valid"], [[4136, 4136], "valid"], [[4137, 4138], "valid"], [[4139, 4139], "valid"], [[4140, 4146], "valid"], [[4147, 4149], "valid"], [[4150, 4153], "valid"], [[4154, 4159], "valid"], [[4160, 4169], "valid"], [[4170, 4175], "valid", [], "NV8"], [[4176, 4185], "valid"], [[4186, 4249], "valid"], [[4250, 4253], "valid"], [[4254, 4255], "valid", [], "NV8"], [[4256, 4293], "disallowed"], [[4294, 4294], "disallowed"], [[4295, 4295], "mapped", [11559]], [[4296, 4300], "disallowed"], [[4301, 4301], "mapped", [11565]], [[4302, 4303], "disallowed"], [[4304, 4342], "valid"], [[4343, 4344], "valid"], [[4345, 4346], "valid"], [[4347, 4347], "valid", [], "NV8"], [[4348, 4348], "mapped", [4316]], [[4349, 4351], "valid"], [[4352, 4441], "valid", [], "NV8"], [[4442, 4446], "valid", [], "NV8"], [[4447, 4448], "disallowed"], [[4449, 4514], "valid", [], "NV8"], [[4515, 4519], "valid", [], "NV8"], [[4520, 4601], "valid", [], "NV8"], [[4602, 4607], "valid", [], "NV8"], [[4608, 4614], "valid"], [[4615, 4615], "valid"], [[4616, 4678], "valid"], [[4679, 4679], "valid"], [[4680, 4680], "valid"], [[4681, 4681], "disallowed"], [[4682, 4685], "valid"], [[4686, 4687], "disallowed"], [[4688, 4694], "valid"], [[4695, 4695], "disallowed"], [[4696, 4696], "valid"], [[4697, 4697], "disallowed"], [[4698, 4701], "valid"], [[4702, 4703], "disallowed"], [[4704, 4742], "valid"], [[4743, 4743], "valid"], [[4744, 4744], "valid"], [[4745, 4745], "disallowed"], [[4746, 4749], "valid"], [[4750, 4751], "disallowed"], [[4752, 4782], "valid"], [[4783, 4783], "valid"], [[4784, 4784], "valid"], [[4785, 4785], "disallowed"], [[4786, 4789], "valid"], [[4790, 4791], "disallowed"], [[4792, 4798], "valid"], [[4799, 4799], "disallowed"], [[4800, 4800], "valid"], [[4801, 4801], "disallowed"], [[4802, 4805], "valid"], [[4806, 4807], "disallowed"], [[4808, 4814], "valid"], [[4815, 4815], "valid"], [[4816, 4822], "valid"], [[4823, 4823], "disallowed"], [[4824, 4846], "valid"], [[4847, 4847], "valid"], [[4848, 4878], "valid"], [[4879, 4879], "valid"], [[4880, 4880], "valid"], [[4881, 4881], "disallowed"], [[4882, 4885], "valid"], [[4886, 4887], "disallowed"], [[4888, 4894], "valid"], [[4895, 4895], "valid"], [[4896, 4934], "valid"], [[4935, 4935], "valid"], [[4936, 4954], "valid"], [[4955, 4956], "disallowed"], [[4957, 4958], "valid"], [[4959, 4959], "valid"], [[4960, 4960], "valid", [], "NV8"], [[4961, 4988], "valid", [], "NV8"], [[4989, 4991], "disallowed"], [[4992, 5007], "valid"], [[5008, 5017], "valid", [], "NV8"], [[5018, 5023], "disallowed"], [[5024, 5108], "valid"], [[5109, 5109], "valid"], [[5110, 5111], "disallowed"], [[5112, 5112], "mapped", [5104]], [[5113, 5113], "mapped", [5105]], [[5114, 5114], "mapped", [5106]], [[5115, 5115], "mapped", [5107]], [[5116, 5116], "mapped", [5108]], [[5117, 5117], "mapped", [5109]], [[5118, 5119], "disallowed"], [[5120, 5120], "valid", [], "NV8"], [[5121, 5740], "valid"], [[5741, 5742], "valid", [], "NV8"], [[5743, 5750], "valid"], [[5751, 5759], "valid"], [[5760, 5760], "disallowed"], [[5761, 5786], "valid"], [[5787, 5788], "valid", [], "NV8"], [[5789, 5791], "disallowed"], [[5792, 5866], "valid"], [[5867, 5872], "valid", [], "NV8"], [[5873, 5880], "valid"], [[5881, 5887], "disallowed"], [[5888, 5900], "valid"], [[5901, 5901], "disallowed"], [[5902, 5908], "valid"], [[5909, 5919], "disallowed"], [[5920, 5940], "valid"], [[5941, 5942], "valid", [], "NV8"], [[5943, 5951], "disallowed"], [[5952, 5971], "valid"], [[5972, 5983], "disallowed"], [[5984, 5996], "valid"], [[5997, 5997], "disallowed"], [[5998, 6000], "valid"], [[6001, 6001], "disallowed"], [[6002, 6003], "valid"], [[6004, 6015], "disallowed"], [[6016, 6067], "valid"], [[6068, 6069], "disallowed"], [[6070, 6099], "valid"], [[6100, 6102], "valid", [], "NV8"], [[6103, 6103], "valid"], [[6104, 6107], "valid", [], "NV8"], [[6108, 6108], "valid"], [[6109, 6109], "valid"], [[6110, 6111], "disallowed"], [[6112, 6121], "valid"], [[6122, 6127], "disallowed"], [[6128, 6137], "valid", [], "NV8"], [[6138, 6143], "disallowed"], [[6144, 6149], "valid", [], "NV8"], [[6150, 6150], "disallowed"], [[6151, 6154], "valid", [], "NV8"], [[6155, 6157], "ignored"], [[6158, 6158], "disallowed"], [[6159, 6159], "disallowed"], [[6160, 6169], "valid"], [[6170, 6175], "disallowed"], [[6176, 6263], "valid"], [[6264, 6271], "disallowed"], [[6272, 6313], "valid"], [[6314, 6314], "valid"], [[6315, 6319], "disallowed"], [[6320, 6389], "valid"], [[6390, 6399], "disallowed"], [[6400, 6428], "valid"], [[6429, 6430], "valid"], [[6431, 6431], "disallowed"], [[6432, 6443], "valid"], [[6444, 6447], "disallowed"], [[6448, 6459], "valid"], [[6460, 6463], "disallowed"], [[6464, 6464], "valid", [], "NV8"], [[6465, 6467], "disallowed"], [[6468, 6469], "valid", [], "NV8"], [[6470, 6509], "valid"], [[6510, 6511], "disallowed"], [[6512, 6516], "valid"], [[6517, 6527], "disallowed"], [[6528, 6569], "valid"], [[6570, 6571], "valid"], [[6572, 6575], "disallowed"], [[6576, 6601], "valid"], [[6602, 6607], "disallowed"], [[6608, 6617], "valid"], [[6618, 6618], "valid", [], "XV8"], [[6619, 6621], "disallowed"], [[6622, 6623], "valid", [], "NV8"], [[6624, 6655], "valid", [], "NV8"], [[6656, 6683], "valid"], [[6684, 6685], "disallowed"], [[6686, 6687], "valid", [], "NV8"], [[6688, 6750], "valid"], [[6751, 6751], "disallowed"], [[6752, 6780], "valid"], [[6781, 6782], "disallowed"], [[6783, 6793], "valid"], [[6794, 6799], "disallowed"], [[6800, 6809], "valid"], [[6810, 6815], "disallowed"], [[6816, 6822], "valid", [], "NV8"], [[6823, 6823], "valid"], [[6824, 6829], "valid", [], "NV8"], [[6830, 6831], "disallowed"], [[6832, 6845], "valid"], [[6846, 6846], "valid", [], "NV8"], [[6847, 6911], "disallowed"], [[6912, 6987], "valid"], [[6988, 6991], "disallowed"], [[6992, 7001], "valid"], [[7002, 7018], "valid", [], "NV8"], [[7019, 7027], "valid"], [[7028, 7036], "valid", [], "NV8"], [[7037, 7039], "disallowed"], [[7040, 7082], "valid"], [[7083, 7085], "valid"], [[7086, 7097], "valid"], [[7098, 7103], "valid"], [[7104, 7155], "valid"], [[7156, 7163], "disallowed"], [[7164, 7167], "valid", [], "NV8"], [[7168, 7223], "valid"], [[7224, 7226], "disallowed"], [[7227, 7231], "valid", [], "NV8"], [[7232, 7241], "valid"], [[7242, 7244], "disallowed"], [[7245, 7293], "valid"], [[7294, 7295], "valid", [], "NV8"], [[7296, 7359], "disallowed"], [[7360, 7367], "valid", [], "NV8"], [[7368, 7375], "disallowed"], [[7376, 7378], "valid"], [[7379, 7379], "valid", [], "NV8"], [[7380, 7410], "valid"], [[7411, 7414], "valid"], [[7415, 7415], "disallowed"], [[7416, 7417], "valid"], [[7418, 7423], "disallowed"], [[7424, 7467], "valid"], [[7468, 7468], "mapped", [97]], [[7469, 7469], "mapped", [230]], [[7470, 7470], "mapped", [98]], [[7471, 7471], "valid"], [[7472, 7472], "mapped", [100]], [[7473, 7473], "mapped", [101]], [[7474, 7474], "mapped", [477]], [[7475, 7475], "mapped", [103]], [[7476, 7476], "mapped", [104]], [[7477, 7477], "mapped", [105]], [[7478, 7478], "mapped", [106]], [[7479, 7479], "mapped", [107]], [[7480, 7480], "mapped", [108]], [[7481, 7481], "mapped", [109]], [[7482, 7482], "mapped", [110]], [[7483, 7483], "valid"], [[7484, 7484], "mapped", [111]], [[7485, 7485], "mapped", [547]], [[7486, 7486], "mapped", [112]], [[7487, 7487], "mapped", [114]], [[7488, 7488], "mapped", [116]], [[7489, 7489], "mapped", [117]], [[7490, 7490], "mapped", [119]], [[7491, 7491], "mapped", [97]], [[7492, 7492], "mapped", [592]], [[7493, 7493], "mapped", [593]], [[7494, 7494], "mapped", [7426]], [[7495, 7495], "mapped", [98]], [[7496, 7496], "mapped", [100]], [[7497, 7497], "mapped", [101]], [[7498, 7498], "mapped", [601]], [[7499, 7499], "mapped", [603]], [[7500, 7500], "mapped", [604]], [[7501, 7501], "mapped", [103]], [[7502, 7502], "valid"], [[7503, 7503], "mapped", [107]], [[7504, 7504], "mapped", [109]], [[7505, 7505], "mapped", [331]], [[7506, 7506], "mapped", [111]], [[7507, 7507], "mapped", [596]], [[7508, 7508], "mapped", [7446]], [[7509, 7509], "mapped", [7447]], [[7510, 7510], "mapped", [112]], [[7511, 7511], "mapped", [116]], [[7512, 7512], "mapped", [117]], [[7513, 7513], "mapped", [7453]], [[7514, 7514], "mapped", [623]], [[7515, 7515], "mapped", [118]], [[7516, 7516], "mapped", [7461]], [[7517, 7517], "mapped", [946]], [[7518, 7518], "mapped", [947]], [[7519, 7519], "mapped", [948]], [[7520, 7520], "mapped", [966]], [[7521, 7521], "mapped", [967]], [[7522, 7522], "mapped", [105]], [[7523, 7523], "mapped", [114]], [[7524, 7524], "mapped", [117]], [[7525, 7525], "mapped", [118]], [[7526, 7526], "mapped", [946]], [[7527, 7527], "mapped", [947]], [[7528, 7528], "mapped", [961]], [[7529, 7529], "mapped", [966]], [[7530, 7530], "mapped", [967]], [[7531, 7531], "valid"], [[7532, 7543], "valid"], [[7544, 7544], "mapped", [1085]], [[7545, 7578], "valid"], [[7579, 7579], "mapped", [594]], [[7580, 7580], "mapped", [99]], [[7581, 7581], "mapped", [597]], [[7582, 7582], "mapped", [240]], [[7583, 7583], "mapped", [604]], [[7584, 7584], "mapped", [102]], [[7585, 7585], "mapped", [607]], [[7586, 7586], "mapped", [609]], [[7587, 7587], "mapped", [613]], [[7588, 7588], "mapped", [616]], [[7589, 7589], "mapped", [617]], [[7590, 7590], "mapped", [618]], [[7591, 7591], "mapped", [7547]], [[7592, 7592], "mapped", [669]], [[7593, 7593], "mapped", [621]], [[7594, 7594], "mapped", [7557]], [[7595, 7595], "mapped", [671]], [[7596, 7596], "mapped", [625]], [[7597, 7597], "mapped", [624]], [[7598, 7598], "mapped", [626]], [[7599, 7599], "mapped", [627]], [[7600, 7600], "mapped", [628]], [[7601, 7601], "mapped", [629]], [[7602, 7602], "mapped", [632]], [[7603, 7603], "mapped", [642]], [[7604, 7604], "mapped", [643]], [[7605, 7605], "mapped", [427]], [[7606, 7606], "mapped", [649]], [[7607, 7607], "mapped", [650]], [[7608, 7608], "mapped", [7452]], [[7609, 7609], "mapped", [651]], [[7610, 7610], "mapped", [652]], [[7611, 7611], "mapped", [122]], [[7612, 7612], "mapped", [656]], [[7613, 7613], "mapped", [657]], [[7614, 7614], "mapped", [658]], [[7615, 7615], "mapped", [952]], [[7616, 7619], "valid"], [[7620, 7626], "valid"], [[7627, 7654], "valid"], [[7655, 7669], "valid"], [[7670, 7675], "disallowed"], [[7676, 7676], "valid"], [[7677, 7677], "valid"], [[7678, 7679], "valid"], [[7680, 7680], "mapped", [7681]], [[7681, 7681], "valid"], [[7682, 7682], "mapped", [7683]], [[7683, 7683], "valid"], [[7684, 7684], "mapped", [7685]], [[7685, 7685], "valid"], [[7686, 7686], "mapped", [7687]], [[7687, 7687], "valid"], [[7688, 7688], "mapped", [7689]], [[7689, 7689], "valid"], [[7690, 7690], "mapped", [7691]], [[7691, 7691], "valid"], [[7692, 7692], "mapped", [7693]], [[7693, 7693], "valid"], [[7694, 7694], "mapped", [7695]], [[7695, 7695], "valid"], [[7696, 7696], "mapped", [7697]], [[7697, 7697], "valid"], [[7698, 7698], "mapped", [7699]], [[7699, 7699], "valid"], [[7700, 7700], "mapped", [7701]], [[7701, 7701], "valid"], [[7702, 7702], "mapped", [7703]], [[7703, 7703], "valid"], [[7704, 7704], "mapped", [7705]], [[7705, 7705], "valid"], [[7706, 7706], "mapped", [7707]], [[7707, 7707], "valid"], [[7708, 7708], "mapped", [7709]], [[7709, 7709], "valid"], [[7710, 7710], "mapped", [7711]], [[7711, 7711], "valid"], [[7712, 7712], "mapped", [7713]], [[7713, 7713], "valid"], [[7714, 7714], "mapped", [7715]], [[7715, 7715], "valid"], [[7716, 7716], "mapped", [7717]], [[7717, 7717], "valid"], [[7718, 7718], "mapped", [7719]], [[7719, 7719], "valid"], [[7720, 7720], "mapped", [7721]], [[7721, 7721], "valid"], [[7722, 7722], "mapped", [7723]], [[7723, 7723], "valid"], [[7724, 7724], "mapped", [7725]], [[7725, 7725], "valid"], [[7726, 7726], "mapped", [7727]], [[7727, 7727], "valid"], [[7728, 7728], "mapped", [7729]], [[7729, 7729], "valid"], [[7730, 7730], "mapped", [7731]], [[7731, 7731], "valid"], [[7732, 7732], "mapped", [7733]], [[7733, 7733], "valid"], [[7734, 7734], "mapped", [7735]], [[7735, 7735], "valid"], [[7736, 7736], "mapped", [7737]], [[7737, 7737], "valid"], [[7738, 7738], "mapped", [7739]], [[7739, 7739], "valid"], [[7740, 7740], "mapped", [7741]], [[7741, 7741], "valid"], [[7742, 7742], "mapped", [7743]], [[7743, 7743], "valid"], [[7744, 7744], "mapped", [7745]], [[7745, 7745], "valid"], [[7746, 7746], "mapped", [7747]], [[7747, 7747], "valid"], [[7748, 7748], "mapped", [7749]], [[7749, 7749], "valid"], [[7750, 7750], "mapped", [7751]], [[7751, 7751], "valid"], [[7752, 7752], "mapped", [7753]], [[7753, 7753], "valid"], [[7754, 7754], "mapped", [7755]], [[7755, 7755], "valid"], [[7756, 7756], "mapped", [7757]], [[7757, 7757], "valid"], [[7758, 7758], "mapped", [7759]], [[7759, 7759], "valid"], [[7760, 7760], "mapped", [7761]], [[7761, 7761], "valid"], [[7762, 7762], "mapped", [7763]], [[7763, 7763], "valid"], [[7764, 7764], "mapped", [7765]], [[7765, 7765], "valid"], [[7766, 7766], "mapped", [7767]], [[7767, 7767], "valid"], [[7768, 7768], "mapped", [7769]], [[7769, 7769], "valid"], [[7770, 7770], "mapped", [7771]], [[7771, 7771], "valid"], [[7772, 7772], "mapped", [7773]], [[7773, 7773], "valid"], [[7774, 7774], "mapped", [7775]], [[7775, 7775], "valid"], [[7776, 7776], "mapped", [7777]], [[7777, 7777], "valid"], [[7778, 7778], "mapped", [7779]], [[7779, 7779], "valid"], [[7780, 7780], "mapped", [7781]], [[7781, 7781], "valid"], [[7782, 7782], "mapped", [7783]], [[7783, 7783], "valid"], [[7784, 7784], "mapped", [7785]], [[7785, 7785], "valid"], [[7786, 7786], "mapped", [7787]], [[7787, 7787], "valid"], [[7788, 7788], "mapped", [7789]], [[7789, 7789], "valid"], [[7790, 7790], "mapped", [7791]], [[7791, 7791], "valid"], [[7792, 7792], "mapped", [7793]], [[7793, 7793], "valid"], [[7794, 7794], "mapped", [7795]], [[7795, 7795], "valid"], [[7796, 7796], "mapped", [7797]], [[7797, 7797], "valid"], [[7798, 7798], "mapped", [7799]], [[7799, 7799], "valid"], [[7800, 7800], "mapped", [7801]], [[7801, 7801], "valid"], [[7802, 7802], "mapped", [7803]], [[7803, 7803], "valid"], [[7804, 7804], "mapped", [7805]], [[7805, 7805], "valid"], [[7806, 7806], "mapped", [7807]], [[7807, 7807], "valid"], [[7808, 7808], "mapped", [7809]], [[7809, 7809], "valid"], [[7810, 7810], "mapped", [7811]], [[7811, 7811], "valid"], [[7812, 7812], "mapped", [7813]], [[7813, 7813], "valid"], [[7814, 7814], "mapped", [7815]], [[7815, 7815], "valid"], [[7816, 7816], "mapped", [7817]], [[7817, 7817], "valid"], [[7818, 7818], "mapped", [7819]], [[7819, 7819], "valid"], [[7820, 7820], "mapped", [7821]], [[7821, 7821], "valid"], [[7822, 7822], "mapped", [7823]], [[7823, 7823], "valid"], [[7824, 7824], "mapped", [7825]], [[7825, 7825], "valid"], [[7826, 7826], "mapped", [7827]], [[7827, 7827], "valid"], [[7828, 7828], "mapped", [7829]], [[7829, 7833], "valid"], [[7834, 7834], "mapped", [97, 702]], [[7835, 7835], "mapped", [7777]], [[7836, 7837], "valid"], [[7838, 7838], "mapped", [115, 115]], [[7839, 7839], "valid"], [[7840, 7840], "mapped", [7841]], [[7841, 7841], "valid"], [[7842, 7842], "mapped", [7843]], [[7843, 7843], "valid"], [[7844, 7844], "mapped", [7845]], [[7845, 7845], "valid"], [[7846, 7846], "mapped", [7847]], [[7847, 7847], "valid"], [[7848, 7848], "mapped", [7849]], [[7849, 7849], "valid"], [[7850, 7850], "mapped", [7851]], [[7851, 7851], "valid"], [[7852, 7852], "mapped", [7853]], [[7853, 7853], "valid"], [[7854, 7854], "mapped", [7855]], [[7855, 7855], "valid"], [[7856, 7856], "mapped", [7857]], [[7857, 7857], "valid"], [[7858, 7858], "mapped", [7859]], [[7859, 7859], "valid"], [[7860, 7860], "mapped", [7861]], [[7861, 7861], "valid"], [[7862, 7862], "mapped", [7863]], [[7863, 7863], "valid"], [[7864, 7864], "mapped", [7865]], [[7865, 7865], "valid"], [[7866, 7866], "mapped", [7867]], [[7867, 7867], "valid"], [[7868, 7868], "mapped", [7869]], [[7869, 7869], "valid"], [[7870, 7870], "mapped", [7871]], [[7871, 7871], "valid"], [[7872, 7872], "mapped", [7873]], [[7873, 7873], "valid"], [[7874, 7874], "mapped", [7875]], [[7875, 7875], "valid"], [[7876, 7876], "mapped", [7877]], [[7877, 7877], "valid"], [[7878, 7878], "mapped", [7879]], [[7879, 7879], "valid"], [[7880, 7880], "mapped", [7881]], [[7881, 7881], "valid"], [[7882, 7882], "mapped", [7883]], [[7883, 7883], "valid"], [[7884, 7884], "mapped", [7885]], [[7885, 7885], "valid"], [[7886, 7886], "mapped", [7887]], [[7887, 7887], "valid"], [[7888, 7888], "mapped", [7889]], [[7889, 7889], "valid"], [[7890, 7890], "mapped", [7891]], [[7891, 7891], "valid"], [[7892, 7892], "mapped", [7893]], [[7893, 7893], "valid"], [[7894, 7894], "mapped", [7895]], [[7895, 7895], "valid"], [[7896, 7896], "mapped", [7897]], [[7897, 7897], "valid"], [[7898, 7898], "mapped", [7899]], [[7899, 7899], "valid"], [[7900, 7900], "mapped", [7901]], [[7901, 7901], "valid"], [[7902, 7902], "mapped", [7903]], [[7903, 7903], "valid"], [[7904, 7904], "mapped", [7905]], [[7905, 7905], "valid"], [[7906, 7906], "mapped", [7907]], [[7907, 7907], "valid"], [[7908, 7908], "mapped", [7909]], [[7909, 7909], "valid"], [[7910, 7910], "mapped", [7911]], [[7911, 7911], "valid"], [[7912, 7912], "mapped", [7913]], [[7913, 7913], "valid"], [[7914, 7914], "mapped", [7915]], [[7915, 7915], "valid"], [[7916, 7916], "mapped", [7917]], [[7917, 7917], "valid"], [[7918, 7918], "mapped", [7919]], [[7919, 7919], "valid"], [[7920, 7920], "mapped", [7921]], [[7921, 7921], "valid"], [[7922, 7922], "mapped", [7923]], [[7923, 7923], "valid"], [[7924, 7924], "mapped", [7925]], [[7925, 7925], "valid"], [[7926, 7926], "mapped", [7927]], [[7927, 7927], "valid"], [[7928, 7928], "mapped", [7929]], [[7929, 7929], "valid"], [[7930, 7930], "mapped", [7931]], [[7931, 7931], "valid"], [[7932, 7932], "mapped", [7933]], [[7933, 7933], "valid"], [[7934, 7934], "mapped", [7935]], [[7935, 7935], "valid"], [[7936, 7943], "valid"], [[7944, 7944], "mapped", [7936]], [[7945, 7945], "mapped", [7937]], [[7946, 7946], "mapped", [7938]], [[7947, 7947], "mapped", [7939]], [[7948, 7948], "mapped", [7940]], [[7949, 7949], "mapped", [7941]], [[7950, 7950], "mapped", [7942]], [[7951, 7951], "mapped", [7943]], [[7952, 7957], "valid"], [[7958, 7959], "disallowed"], [[7960, 7960], "mapped", [7952]], [[7961, 7961], "mapped", [7953]], [[7962, 7962], "mapped", [7954]], [[7963, 7963], "mapped", [7955]], [[7964, 7964], "mapped", [7956]], [[7965, 7965], "mapped", [7957]], [[7966, 7967], "disallowed"], [[7968, 7975], "valid"], [[7976, 7976], "mapped", [7968]], [[7977, 7977], "mapped", [7969]], [[7978, 7978], "mapped", [7970]], [[7979, 7979], "mapped", [7971]], [[7980, 7980], "mapped", [7972]], [[7981, 7981], "mapped", [7973]], [[7982, 7982], "mapped", [7974]], [[7983, 7983], "mapped", [7975]], [[7984, 7991], "valid"], [[7992, 7992], "mapped", [7984]], [[7993, 7993], "mapped", [7985]], [[7994, 7994], "mapped", [7986]], [[7995, 7995], "mapped", [7987]], [[7996, 7996], "mapped", [7988]], [[7997, 7997], "mapped", [7989]], [[7998, 7998], "mapped", [7990]], [[7999, 7999], "mapped", [7991]], [[8000, 8005], "valid"], [[8006, 8007], "disallowed"], [[8008, 8008], "mapped", [8000]], [[8009, 8009], "mapped", [8001]], [[8010, 8010], "mapped", [8002]], [[8011, 8011], "mapped", [8003]], [[8012, 8012], "mapped", [8004]], [[8013, 8013], "mapped", [8005]], [[8014, 8015], "disallowed"], [[8016, 8023], "valid"], [[8024, 8024], "disallowed"], [[8025, 8025], "mapped", [8017]], [[8026, 8026], "disallowed"], [[8027, 8027], "mapped", [8019]], [[8028, 8028], "disallowed"], [[8029, 8029], "mapped", [8021]], [[8030, 8030], "disallowed"], [[8031, 8031], "mapped", [8023]], [[8032, 8039], "valid"], [[8040, 8040], "mapped", [8032]], [[8041, 8041], "mapped", [8033]], [[8042, 8042], "mapped", [8034]], [[8043, 8043], "mapped", [8035]], [[8044, 8044], "mapped", [8036]], [[8045, 8045], "mapped", [8037]], [[8046, 8046], "mapped", [8038]], [[8047, 8047], "mapped", [8039]], [[8048, 8048], "valid"], [[8049, 8049], "mapped", [940]], [[8050, 8050], "valid"], [[8051, 8051], "mapped", [941]], [[8052, 8052], "valid"], [[8053, 8053], "mapped", [942]], [[8054, 8054], "valid"], [[8055, 8055], "mapped", [943]], [[8056, 8056], "valid"], [[8057, 8057], "mapped", [972]], [[8058, 8058], "valid"], [[8059, 8059], "mapped", [973]], [[8060, 8060], "valid"], [[8061, 8061], "mapped", [974]], [[8062, 8063], "disallowed"], [[8064, 8064], "mapped", [7936, 953]], [[8065, 8065], "mapped", [7937, 953]], [[8066, 8066], "mapped", [7938, 953]], [[8067, 8067], "mapped", [7939, 953]], [[8068, 8068], "mapped", [7940, 953]], [[8069, 8069], "mapped", [7941, 953]], [[8070, 8070], "mapped", [7942, 953]], [[8071, 8071], "mapped", [7943, 953]], [[8072, 8072], "mapped", [7936, 953]], [[8073, 8073], "mapped", [7937, 953]], [[8074, 8074], "mapped", [7938, 953]], [[8075, 8075], "mapped", [7939, 953]], [[8076, 8076], "mapped", [7940, 953]], [[8077, 8077], "mapped", [7941, 953]], [[8078, 8078], "mapped", [7942, 953]], [[8079, 8079], "mapped", [7943, 953]], [[8080, 8080], "mapped", [7968, 953]], [[8081, 8081], "mapped", [7969, 953]], [[8082, 8082], "mapped", [7970, 953]], [[8083, 8083], "mapped", [7971, 953]], [[8084, 8084], "mapped", [7972, 953]], [[8085, 8085], "mapped", [7973, 953]], [[8086, 8086], "mapped", [7974, 953]], [[8087, 8087], "mapped", [7975, 953]], [[8088, 8088], "mapped", [7968, 953]], [[8089, 8089], "mapped", [7969, 953]], [[8090, 8090], "mapped", [7970, 953]], [[8091, 8091], "mapped", [7971, 953]], [[8092, 8092], "mapped", [7972, 953]], [[8093, 8093], "mapped", [7973, 953]], [[8094, 8094], "mapped", [7974, 953]], [[8095, 8095], "mapped", [7975, 953]], [[8096, 8096], "mapped", [8032, 953]], [[8097, 8097], "mapped", [8033, 953]], [[8098, 8098], "mapped", [8034, 953]], [[8099, 8099], "mapped", [8035, 953]], [[8100, 8100], "mapped", [8036, 953]], [[8101, 8101], "mapped", [8037, 953]], [[8102, 8102], "mapped", [8038, 953]], [[8103, 8103], "mapped", [8039, 953]], [[8104, 8104], "mapped", [8032, 953]], [[8105, 8105], "mapped", [8033, 953]], [[8106, 8106], "mapped", [8034, 953]], [[8107, 8107], "mapped", [8035, 953]], [[8108, 8108], "mapped", [8036, 953]], [[8109, 8109], "mapped", [8037, 953]], [[8110, 8110], "mapped", [8038, 953]], [[8111, 8111], "mapped", [8039, 953]], [[8112, 8113], "valid"], [[8114, 8114], "mapped", [8048, 953]], [[8115, 8115], "mapped", [945, 953]], [[8116, 8116], "mapped", [940, 953]], [[8117, 8117], "disallowed"], [[8118, 8118], "valid"], [[8119, 8119], "mapped", [8118, 953]], [[8120, 8120], "mapped", [8112]], [[8121, 8121], "mapped", [8113]], [[8122, 8122], "mapped", [8048]], [[8123, 8123], "mapped", [940]], [[8124, 8124], "mapped", [945, 953]], [[8125, 8125], "disallowed_STD3_mapped", [32, 787]], [[8126, 8126], "mapped", [953]], [[8127, 8127], "disallowed_STD3_mapped", [32, 787]], [[8128, 8128], "disallowed_STD3_mapped", [32, 834]], [[8129, 8129], "disallowed_STD3_mapped", [32, 776, 834]], [[8130, 8130], "mapped", [8052, 953]], [[8131, 8131], "mapped", [951, 953]], [[8132, 8132], "mapped", [942, 953]], [[8133, 8133], "disallowed"], [[8134, 8134], "valid"], [[8135, 8135], "mapped", [8134, 953]], [[8136, 8136], "mapped", [8050]], [[8137, 8137], "mapped", [941]], [[8138, 8138], "mapped", [8052]], [[8139, 8139], "mapped", [942]], [[8140, 8140], "mapped", [951, 953]], [[8141, 8141], "disallowed_STD3_mapped", [32, 787, 768]], [[8142, 8142], "disallowed_STD3_mapped", [32, 787, 769]], [[8143, 8143], "disallowed_STD3_mapped", [32, 787, 834]], [[8144, 8146], "valid"], [[8147, 8147], "mapped", [912]], [[8148, 8149], "disallowed"], [[8150, 8151], "valid"], [[8152, 8152], "mapped", [8144]], [[8153, 8153], "mapped", [8145]], [[8154, 8154], "mapped", [8054]], [[8155, 8155], "mapped", [943]], [[8156, 8156], "disallowed"], [[8157, 8157], "disallowed_STD3_mapped", [32, 788, 768]], [[8158, 8158], "disallowed_STD3_mapped", [32, 788, 769]], [[8159, 8159], "disallowed_STD3_mapped", [32, 788, 834]], [[8160, 8162], "valid"], [[8163, 8163], "mapped", [944]], [[8164, 8167], "valid"], [[8168, 8168], "mapped", [8160]], [[8169, 8169], "mapped", [8161]], [[8170, 8170], "mapped", [8058]], [[8171, 8171], "mapped", [973]], [[8172, 8172], "mapped", [8165]], [[8173, 8173], "disallowed_STD3_mapped", [32, 776, 768]], [[8174, 8174], "disallowed_STD3_mapped", [32, 776, 769]], [[8175, 8175], "disallowed_STD3_mapped", [96]], [[8176, 8177], "disallowed"], [[8178, 8178], "mapped", [8060, 953]], [[8179, 8179], "mapped", [969, 953]], [[8180, 8180], "mapped", [974, 953]], [[8181, 8181], "disallowed"], [[8182, 8182], "valid"], [[8183, 8183], "mapped", [8182, 953]], [[8184, 8184], "mapped", [8056]], [[8185, 8185], "mapped", [972]], [[8186, 8186], "mapped", [8060]], [[8187, 8187], "mapped", [974]], [[8188, 8188], "mapped", [969, 953]], [[8189, 8189], "disallowed_STD3_mapped", [32, 769]], [[8190, 8190], "disallowed_STD3_mapped", [32, 788]], [[8191, 8191], "disallowed"], [[8192, 8202], "disallowed_STD3_mapped", [32]], [[8203, 8203], "ignored"], [[8204, 8205], "deviation", []], [[8206, 8207], "disallowed"], [[8208, 8208], "valid", [], "NV8"], [[8209, 8209], "mapped", [8208]], [[8210, 8214], "valid", [], "NV8"], [[8215, 8215], "disallowed_STD3_mapped", [32, 819]], [[8216, 8227], "valid", [], "NV8"], [[8228, 8230], "disallowed"], [[8231, 8231], "valid", [], "NV8"], [[8232, 8238], "disallowed"], [[8239, 8239], "disallowed_STD3_mapped", [32]], [[8240, 8242], "valid", [], "NV8"], [[8243, 8243], "mapped", [8242, 8242]], [[8244, 8244], "mapped", [8242, 8242, 8242]], [[8245, 8245], "valid", [], "NV8"], [[8246, 8246], "mapped", [8245, 8245]], [[8247, 8247], "mapped", [8245, 8245, 8245]], [[8248, 8251], "valid", [], "NV8"], [[8252, 8252], "disallowed_STD3_mapped", [33, 33]], [[8253, 8253], "valid", [], "NV8"], [[8254, 8254], "disallowed_STD3_mapped", [32, 773]], [[8255, 8262], "valid", [], "NV8"], [[8263, 8263], "disallowed_STD3_mapped", [63, 63]], [[8264, 8264], "disallowed_STD3_mapped", [63, 33]], [[8265, 8265], "disallowed_STD3_mapped", [33, 63]], [[8266, 8269], "valid", [], "NV8"], [[8270, 8274], "valid", [], "NV8"], [[8275, 8276], "valid", [], "NV8"], [[8277, 8278], "valid", [], "NV8"], [[8279, 8279], "mapped", [8242, 8242, 8242, 8242]], [[8280, 8286], "valid", [], "NV8"], [[8287, 8287], "disallowed_STD3_mapped", [32]], [[8288, 8288], "ignored"], [[8289, 8291], "disallowed"], [[8292, 8292], "ignored"], [[8293, 8293], "disallowed"], [[8294, 8297], "disallowed"], [[8298, 8303], "disallowed"], [[8304, 8304], "mapped", [48]], [[8305, 8305], "mapped", [105]], [[8306, 8307], "disallowed"], [[8308, 8308], "mapped", [52]], [[8309, 8309], "mapped", [53]], [[8310, 8310], "mapped", [54]], [[8311, 8311], "mapped", [55]], [[8312, 8312], "mapped", [56]], [[8313, 8313], "mapped", [57]], [[8314, 8314], "disallowed_STD3_mapped", [43]], [[8315, 8315], "mapped", [8722]], [[8316, 8316], "disallowed_STD3_mapped", [61]], [[8317, 8317], "disallowed_STD3_mapped", [40]], [[8318, 8318], "disallowed_STD3_mapped", [41]], [[8319, 8319], "mapped", [110]], [[8320, 8320], "mapped", [48]], [[8321, 8321], "mapped", [49]], [[8322, 8322], "mapped", [50]], [[8323, 8323], "mapped", [51]], [[8324, 8324], "mapped", [52]], [[8325, 8325], "mapped", [53]], [[8326, 8326], "mapped", [54]], [[8327, 8327], "mapped", [55]], [[8328, 8328], "mapped", [56]], [[8329, 8329], "mapped", [57]], [[8330, 8330], "disallowed_STD3_mapped", [43]], [[8331, 8331], "mapped", [8722]], [[8332, 8332], "disallowed_STD3_mapped", [61]], [[8333, 8333], "disallowed_STD3_mapped", [40]], [[8334, 8334], "disallowed_STD3_mapped", [41]], [[8335, 8335], "disallowed"], [[8336, 8336], "mapped", [97]], [[8337, 8337], "mapped", [101]], [[8338, 8338], "mapped", [111]], [[8339, 8339], "mapped", [120]], [[8340, 8340], "mapped", [601]], [[8341, 8341], "mapped", [104]], [[8342, 8342], "mapped", [107]], [[8343, 8343], "mapped", [108]], [[8344, 8344], "mapped", [109]], [[8345, 8345], "mapped", [110]], [[8346, 8346], "mapped", [112]], [[8347, 8347], "mapped", [115]], [[8348, 8348], "mapped", [116]], [[8349, 8351], "disallowed"], [[8352, 8359], "valid", [], "NV8"], [[8360, 8360], "mapped", [114, 115]], [[8361, 8362], "valid", [], "NV8"], [[8363, 8363], "valid", [], "NV8"], [[8364, 8364], "valid", [], "NV8"], [[8365, 8367], "valid", [], "NV8"], [[8368, 8369], "valid", [], "NV8"], [[8370, 8373], "valid", [], "NV8"], [[8374, 8376], "valid", [], "NV8"], [[8377, 8377], "valid", [], "NV8"], [[8378, 8378], "valid", [], "NV8"], [[8379, 8381], "valid", [], "NV8"], [[8382, 8382], "valid", [], "NV8"], [[8383, 8399], "disallowed"], [[8400, 8417], "valid", [], "NV8"], [[8418, 8419], "valid", [], "NV8"], [[8420, 8426], "valid", [], "NV8"], [[8427, 8427], "valid", [], "NV8"], [[8428, 8431], "valid", [], "NV8"], [[8432, 8432], "valid", [], "NV8"], [[8433, 8447], "disallowed"], [[8448, 8448], "disallowed_STD3_mapped", [97, 47, 99]], [[8449, 8449], "disallowed_STD3_mapped", [97, 47, 115]], [[8450, 8450], "mapped", [99]], [[8451, 8451], "mapped", [176, 99]], [[8452, 8452], "valid", [], "NV8"], [[8453, 8453], "disallowed_STD3_mapped", [99, 47, 111]], [[8454, 8454], "disallowed_STD3_mapped", [99, 47, 117]], [[8455, 8455], "mapped", [603]], [[8456, 8456], "valid", [], "NV8"], [[8457, 8457], "mapped", [176, 102]], [[8458, 8458], "mapped", [103]], [[8459, 8462], "mapped", [104]], [[8463, 8463], "mapped", [295]], [[8464, 8465], "mapped", [105]], [[8466, 8467], "mapped", [108]], [[8468, 8468], "valid", [], "NV8"], [[8469, 8469], "mapped", [110]], [[8470, 8470], "mapped", [110, 111]], [[8471, 8472], "valid", [], "NV8"], [[8473, 8473], "mapped", [112]], [[8474, 8474], "mapped", [113]], [[8475, 8477], "mapped", [114]], [[8478, 8479], "valid", [], "NV8"], [[8480, 8480], "mapped", [115, 109]], [[8481, 8481], "mapped", [116, 101, 108]], [[8482, 8482], "mapped", [116, 109]], [[8483, 8483], "valid", [], "NV8"], [[8484, 8484], "mapped", [122]], [[8485, 8485], "valid", [], "NV8"], [[8486, 8486], "mapped", [969]], [[8487, 8487], "valid", [], "NV8"], [[8488, 8488], "mapped", [122]], [[8489, 8489], "valid", [], "NV8"], [[8490, 8490], "mapped", [107]], [[8491, 8491], "mapped", [229]], [[8492, 8492], "mapped", [98]], [[8493, 8493], "mapped", [99]], [[8494, 8494], "valid", [], "NV8"], [[8495, 8496], "mapped", [101]], [[8497, 8497], "mapped", [102]], [[8498, 8498], "disallowed"], [[8499, 8499], "mapped", [109]], [[8500, 8500], "mapped", [111]], [[8501, 8501], "mapped", [1488]], [[8502, 8502], "mapped", [1489]], [[8503, 8503], "mapped", [1490]], [[8504, 8504], "mapped", [1491]], [[8505, 8505], "mapped", [105]], [[8506, 8506], "valid", [], "NV8"], [[8507, 8507], "mapped", [102, 97, 120]], [[8508, 8508], "mapped", [960]], [[8509, 8510], "mapped", [947]], [[8511, 8511], "mapped", [960]], [[8512, 8512], "mapped", [8721]], [[8513, 8516], "valid", [], "NV8"], [[8517, 8518], "mapped", [100]], [[8519, 8519], "mapped", [101]], [[8520, 8520], "mapped", [105]], [[8521, 8521], "mapped", [106]], [[8522, 8523], "valid", [], "NV8"], [[8524, 8524], "valid", [], "NV8"], [[8525, 8525], "valid", [], "NV8"], [[8526, 8526], "valid"], [[8527, 8527], "valid", [], "NV8"], [[8528, 8528], "mapped", [49, 8260, 55]], [[8529, 8529], "mapped", [49, 8260, 57]], [[8530, 8530], "mapped", [49, 8260, 49, 48]], [[8531, 8531], "mapped", [49, 8260, 51]], [[8532, 8532], "mapped", [50, 8260, 51]], [[8533, 8533], "mapped", [49, 8260, 53]], [[8534, 8534], "mapped", [50, 8260, 53]], [[8535, 8535], "mapped", [51, 8260, 53]], [[8536, 8536], "mapped", [52, 8260, 53]], [[8537, 8537], "mapped", [49, 8260, 54]], [[8538, 8538], "mapped", [53, 8260, 54]], [[8539, 8539], "mapped", [49, 8260, 56]], [[8540, 8540], "mapped", [51, 8260, 56]], [[8541, 8541], "mapped", [53, 8260, 56]], [[8542, 8542], "mapped", [55, 8260, 56]], [[8543, 8543], "mapped", [49, 8260]], [[8544, 8544], "mapped", [105]], [[8545, 8545], "mapped", [105, 105]], [[8546, 8546], "mapped", [105, 105, 105]], [[8547, 8547], "mapped", [105, 118]], [[8548, 8548], "mapped", [118]], [[8549, 8549], "mapped", [118, 105]], [[8550, 8550], "mapped", [118, 105, 105]], [[8551, 8551], "mapped", [118, 105, 105, 105]], [[8552, 8552], "mapped", [105, 120]], [[8553, 8553], "mapped", [120]], [[8554, 8554], "mapped", [120, 105]], [[8555, 8555], "mapped", [120, 105, 105]], [[8556, 8556], "mapped", [108]], [[8557, 8557], "mapped", [99]], [[8558, 8558], "mapped", [100]], [[8559, 8559], "mapped", [109]], [[8560, 8560], "mapped", [105]], [[8561, 8561], "mapped", [105, 105]], [[8562, 8562], "mapped", [105, 105, 105]], [[8563, 8563], "mapped", [105, 118]], [[8564, 8564], "mapped", [118]], [[8565, 8565], "mapped", [118, 105]], [[8566, 8566], "mapped", [118, 105, 105]], [[8567, 8567], "mapped", [118, 105, 105, 105]], [[8568, 8568], "mapped", [105, 120]], [[8569, 8569], "mapped", [120]], [[8570, 8570], "mapped", [120, 105]], [[8571, 8571], "mapped", [120, 105, 105]], [[8572, 8572], "mapped", [108]], [[8573, 8573], "mapped", [99]], [[8574, 8574], "mapped", [100]], [[8575, 8575], "mapped", [109]], [[8576, 8578], "valid", [], "NV8"], [[8579, 8579], "disallowed"], [[8580, 8580], "valid"], [[8581, 8584], "valid", [], "NV8"], [[8585, 8585], "mapped", [48, 8260, 51]], [[8586, 8587], "valid", [], "NV8"], [[8588, 8591], "disallowed"], [[8592, 8682], "valid", [], "NV8"], [[8683, 8691], "valid", [], "NV8"], [[8692, 8703], "valid", [], "NV8"], [[8704, 8747], "valid", [], "NV8"], [[8748, 8748], "mapped", [8747, 8747]], [[8749, 8749], "mapped", [8747, 8747, 8747]], [[8750, 8750], "valid", [], "NV8"], [[8751, 8751], "mapped", [8750, 8750]], [[8752, 8752], "mapped", [8750, 8750, 8750]], [[8753, 8799], "valid", [], "NV8"], [[8800, 8800], "disallowed_STD3_valid"], [[8801, 8813], "valid", [], "NV8"], [[8814, 8815], "disallowed_STD3_valid"], [[8816, 8945], "valid", [], "NV8"], [[8946, 8959], "valid", [], "NV8"], [[8960, 8960], "valid", [], "NV8"], [[8961, 8961], "valid", [], "NV8"], [[8962, 9000], "valid", [], "NV8"], [[9001, 9001], "mapped", [12296]], [[9002, 9002], "mapped", [12297]], [[9003, 9082], "valid", [], "NV8"], [[9083, 9083], "valid", [], "NV8"], [[9084, 9084], "valid", [], "NV8"], [[9085, 9114], "valid", [], "NV8"], [[9115, 9166], "valid", [], "NV8"], [[9167, 9168], "valid", [], "NV8"], [[9169, 9179], "valid", [], "NV8"], [[9180, 9191], "valid", [], "NV8"], [[9192, 9192], "valid", [], "NV8"], [[9193, 9203], "valid", [], "NV8"], [[9204, 9210], "valid", [], "NV8"], [[9211, 9215], "disallowed"], [[9216, 9252], "valid", [], "NV8"], [[9253, 9254], "valid", [], "NV8"], [[9255, 9279], "disallowed"], [[9280, 9290], "valid", [], "NV8"], [[9291, 9311], "disallowed"], [[9312, 9312], "mapped", [49]], [[9313, 9313], "mapped", [50]], [[9314, 9314], "mapped", [51]], [[9315, 9315], "mapped", [52]], [[9316, 9316], "mapped", [53]], [[9317, 9317], "mapped", [54]], [[9318, 9318], "mapped", [55]], [[9319, 9319], "mapped", [56]], [[9320, 9320], "mapped", [57]], [[9321, 9321], "mapped", [49, 48]], [[9322, 9322], "mapped", [49, 49]], [[9323, 9323], "mapped", [49, 50]], [[9324, 9324], "mapped", [49, 51]], [[9325, 9325], "mapped", [49, 52]], [[9326, 9326], "mapped", [49, 53]], [[9327, 9327], "mapped", [49, 54]], [[9328, 9328], "mapped", [49, 55]], [[9329, 9329], "mapped", [49, 56]], [[9330, 9330], "mapped", [49, 57]], [[9331, 9331], "mapped", [50, 48]], [[9332, 9332], "disallowed_STD3_mapped", [40, 49, 41]], [[9333, 9333], "disallowed_STD3_mapped", [40, 50, 41]], [[9334, 9334], "disallowed_STD3_mapped", [40, 51, 41]], [[9335, 9335], "disallowed_STD3_mapped", [40, 52, 41]], [[9336, 9336], "disallowed_STD3_mapped", [40, 53, 41]], [[9337, 9337], "disallowed_STD3_mapped", [40, 54, 41]], [[9338, 9338], "disallowed_STD3_mapped", [40, 55, 41]], [[9339, 9339], "disallowed_STD3_mapped", [40, 56, 41]], [[9340, 9340], "disallowed_STD3_mapped", [40, 57, 41]], [[9341, 9341], "disallowed_STD3_mapped", [40, 49, 48, 41]], [[9342, 9342], "disallowed_STD3_mapped", [40, 49, 49, 41]], [[9343, 9343], "disallowed_STD3_mapped", [40, 49, 50, 41]], [[9344, 9344], "disallowed_STD3_mapped", [40, 49, 51, 41]], [[9345, 9345], "disallowed_STD3_mapped", [40, 49, 52, 41]], [[9346, 9346], "disallowed_STD3_mapped", [40, 49, 53, 41]], [[9347, 9347], "disallowed_STD3_mapped", [40, 49, 54, 41]], [[9348, 9348], "disallowed_STD3_mapped", [40, 49, 55, 41]], [[9349, 9349], "disallowed_STD3_mapped", [40, 49, 56, 41]], [[9350, 9350], "disallowed_STD3_mapped", [40, 49, 57, 41]], [[9351, 9351], "disallowed_STD3_mapped", [40, 50, 48, 41]], [[9352, 9371], "disallowed"], [[9372, 9372], "disallowed_STD3_mapped", [40, 97, 41]], [[9373, 9373], "disallowed_STD3_mapped", [40, 98, 41]], [[9374, 9374], "disallowed_STD3_mapped", [40, 99, 41]], [[9375, 9375], "disallowed_STD3_mapped", [40, 100, 41]], [[9376, 9376], "disallowed_STD3_mapped", [40, 101, 41]], [[9377, 9377], "disallowed_STD3_mapped", [40, 102, 41]], [[9378, 9378], "disallowed_STD3_mapped", [40, 103, 41]], [[9379, 9379], "disallowed_STD3_mapped", [40, 104, 41]], [[9380, 9380], "disallowed_STD3_mapped", [40, 105, 41]], [[9381, 9381], "disallowed_STD3_mapped", [40, 106, 41]], [[9382, 9382], "disallowed_STD3_mapped", [40, 107, 41]], [[9383, 9383], "disallowed_STD3_mapped", [40, 108, 41]], [[9384, 9384], "disallowed_STD3_mapped", [40, 109, 41]], [[9385, 9385], "disallowed_STD3_mapped", [40, 110, 41]], [[9386, 9386], "disallowed_STD3_mapped", [40, 111, 41]], [[9387, 9387], "disallowed_STD3_mapped", [40, 112, 41]], [[9388, 9388], "disallowed_STD3_mapped", [40, 113, 41]], [[9389, 9389], "disallowed_STD3_mapped", [40, 114, 41]], [[9390, 9390], "disallowed_STD3_mapped", [40, 115, 41]], [[9391, 9391], "disallowed_STD3_mapped", [40, 116, 41]], [[9392, 9392], "disallowed_STD3_mapped", [40, 117, 41]], [[9393, 9393], "disallowed_STD3_mapped", [40, 118, 41]], [[9394, 9394], "disallowed_STD3_mapped", [40, 119, 41]], [[9395, 9395], "disallowed_STD3_mapped", [40, 120, 41]], [[9396, 9396], "disallowed_STD3_mapped", [40, 121, 41]], [[9397, 9397], "disallowed_STD3_mapped", [40, 122, 41]], [[9398, 9398], "mapped", [97]], [[9399, 9399], "mapped", [98]], [[9400, 9400], "mapped", [99]], [[9401, 9401], "mapped", [100]], [[9402, 9402], "mapped", [101]], [[9403, 9403], "mapped", [102]], [[9404, 9404], "mapped", [103]], [[9405, 9405], "mapped", [104]], [[9406, 9406], "mapped", [105]], [[9407, 9407], "mapped", [106]], [[9408, 9408], "mapped", [107]], [[9409, 9409], "mapped", [108]], [[9410, 9410], "mapped", [109]], [[9411, 9411], "mapped", [110]], [[9412, 9412], "mapped", [111]], [[9413, 9413], "mapped", [112]], [[9414, 9414], "mapped", [113]], [[9415, 9415], "mapped", [114]], [[9416, 9416], "mapped", [115]], [[9417, 9417], "mapped", [116]], [[9418, 9418], "mapped", [117]], [[9419, 9419], "mapped", [118]], [[9420, 9420], "mapped", [119]], [[9421, 9421], "mapped", [120]], [[9422, 9422], "mapped", [121]], [[9423, 9423], "mapped", [122]], [[9424, 9424], "mapped", [97]], [[9425, 9425], "mapped", [98]], [[9426, 9426], "mapped", [99]], [[9427, 9427], "mapped", [100]], [[9428, 9428], "mapped", [101]], [[9429, 9429], "mapped", [102]], [[9430, 9430], "mapped", [103]], [[9431, 9431], "mapped", [104]], [[9432, 9432], "mapped", [105]], [[9433, 9433], "mapped", [106]], [[9434, 9434], "mapped", [107]], [[9435, 9435], "mapped", [108]], [[9436, 9436], "mapped", [109]], [[9437, 9437], "mapped", [110]], [[9438, 9438], "mapped", [111]], [[9439, 9439], "mapped", [112]], [[9440, 9440], "mapped", [113]], [[9441, 9441], "mapped", [114]], [[9442, 9442], "mapped", [115]], [[9443, 9443], "mapped", [116]], [[9444, 9444], "mapped", [117]], [[9445, 9445], "mapped", [118]], [[9446, 9446], "mapped", [119]], [[9447, 9447], "mapped", [120]], [[9448, 9448], "mapped", [121]], [[9449, 9449], "mapped", [122]], [[9450, 9450], "mapped", [48]], [[9451, 9470], "valid", [], "NV8"], [[9471, 9471], "valid", [], "NV8"], [[9472, 9621], "valid", [], "NV8"], [[9622, 9631], "valid", [], "NV8"], [[9632, 9711], "valid", [], "NV8"], [[9712, 9719], "valid", [], "NV8"], [[9720, 9727], "valid", [], "NV8"], [[9728, 9747], "valid", [], "NV8"], [[9748, 9749], "valid", [], "NV8"], [[9750, 9751], "valid", [], "NV8"], [[9752, 9752], "valid", [], "NV8"], [[9753, 9753], "valid", [], "NV8"], [[9754, 9839], "valid", [], "NV8"], [[9840, 9841], "valid", [], "NV8"], [[9842, 9853], "valid", [], "NV8"], [[9854, 9855], "valid", [], "NV8"], [[9856, 9865], "valid", [], "NV8"], [[9866, 9873], "valid", [], "NV8"], [[9874, 9884], "valid", [], "NV8"], [[9885, 9885], "valid", [], "NV8"], [[9886, 9887], "valid", [], "NV8"], [[9888, 9889], "valid", [], "NV8"], [[9890, 9905], "valid", [], "NV8"], [[9906, 9906], "valid", [], "NV8"], [[9907, 9916], "valid", [], "NV8"], [[9917, 9919], "valid", [], "NV8"], [[9920, 9923], "valid", [], "NV8"], [[9924, 9933], "valid", [], "NV8"], [[9934, 9934], "valid", [], "NV8"], [[9935, 9953], "valid", [], "NV8"], [[9954, 9954], "valid", [], "NV8"], [[9955, 9955], "valid", [], "NV8"], [[9956, 9959], "valid", [], "NV8"], [[9960, 9983], "valid", [], "NV8"], [[9984, 9984], "valid", [], "NV8"], [[9985, 9988], "valid", [], "NV8"], [[9989, 9989], "valid", [], "NV8"], [[9990, 9993], "valid", [], "NV8"], [[9994, 9995], "valid", [], "NV8"], [[9996, 10023], "valid", [], "NV8"], [[10024, 10024], "valid", [], "NV8"], [[10025, 10059], "valid", [], "NV8"], [[10060, 10060], "valid", [], "NV8"], [[10061, 10061], "valid", [], "NV8"], [[10062, 10062], "valid", [], "NV8"], [[10063, 10066], "valid", [], "NV8"], [[10067, 10069], "valid", [], "NV8"], [[10070, 10070], "valid", [], "NV8"], [[10071, 10071], "valid", [], "NV8"], [[10072, 10078], "valid", [], "NV8"], [[10079, 10080], "valid", [], "NV8"], [[10081, 10087], "valid", [], "NV8"], [[10088, 10101], "valid", [], "NV8"], [[10102, 10132], "valid", [], "NV8"], [[10133, 10135], "valid", [], "NV8"], [[10136, 10159], "valid", [], "NV8"], [[10160, 10160], "valid", [], "NV8"], [[10161, 10174], "valid", [], "NV8"], [[10175, 10175], "valid", [], "NV8"], [[10176, 10182], "valid", [], "NV8"], [[10183, 10186], "valid", [], "NV8"], [[10187, 10187], "valid", [], "NV8"], [[10188, 10188], "valid", [], "NV8"], [[10189, 10189], "valid", [], "NV8"], [[10190, 10191], "valid", [], "NV8"], [[10192, 10219], "valid", [], "NV8"], [[10220, 10223], "valid", [], "NV8"], [[10224, 10239], "valid", [], "NV8"], [[10240, 10495], "valid", [], "NV8"], [[10496, 10763], "valid", [], "NV8"], [[10764, 10764], "mapped", [8747, 8747, 8747, 8747]], [[10765, 10867], "valid", [], "NV8"], [[10868, 10868], "disallowed_STD3_mapped", [58, 58, 61]], [[10869, 10869], "disallowed_STD3_mapped", [61, 61]], [[10870, 10870], "disallowed_STD3_mapped", [61, 61, 61]], [[10871, 10971], "valid", [], "NV8"], [[10972, 10972], "mapped", [10973, 824]], [[10973, 11007], "valid", [], "NV8"], [[11008, 11021], "valid", [], "NV8"], [[11022, 11027], "valid", [], "NV8"], [[11028, 11034], "valid", [], "NV8"], [[11035, 11039], "valid", [], "NV8"], [[11040, 11043], "valid", [], "NV8"], [[11044, 11084], "valid", [], "NV8"], [[11085, 11087], "valid", [], "NV8"], [[11088, 11092], "valid", [], "NV8"], [[11093, 11097], "valid", [], "NV8"], [[11098, 11123], "valid", [], "NV8"], [[11124, 11125], "disallowed"], [[11126, 11157], "valid", [], "NV8"], [[11158, 11159], "disallowed"], [[11160, 11193], "valid", [], "NV8"], [[11194, 11196], "disallowed"], [[11197, 11208], "valid", [], "NV8"], [[11209, 11209], "disallowed"], [[11210, 11217], "valid", [], "NV8"], [[11218, 11243], "disallowed"], [[11244, 11247], "valid", [], "NV8"], [[11248, 11263], "disallowed"], [[11264, 11264], "mapped", [11312]], [[11265, 11265], "mapped", [11313]], [[11266, 11266], "mapped", [11314]], [[11267, 11267], "mapped", [11315]], [[11268, 11268], "mapped", [11316]], [[11269, 11269], "mapped", [11317]], [[11270, 11270], "mapped", [11318]], [[11271, 11271], "mapped", [11319]], [[11272, 11272], "mapped", [11320]], [[11273, 11273], "mapped", [11321]], [[11274, 11274], "mapped", [11322]], [[11275, 11275], "mapped", [11323]], [[11276, 11276], "mapped", [11324]], [[11277, 11277], "mapped", [11325]], [[11278, 11278], "mapped", [11326]], [[11279, 11279], "mapped", [11327]], [[11280, 11280], "mapped", [11328]], [[11281, 11281], "mapped", [11329]], [[11282, 11282], "mapped", [11330]], [[11283, 11283], "mapped", [11331]], [[11284, 11284], "mapped", [11332]], [[11285, 11285], "mapped", [11333]], [[11286, 11286], "mapped", [11334]], [[11287, 11287], "mapped", [11335]], [[11288, 11288], "mapped", [11336]], [[11289, 11289], "mapped", [11337]], [[11290, 11290], "mapped", [11338]], [[11291, 11291], "mapped", [11339]], [[11292, 11292], "mapped", [11340]], [[11293, 11293], "mapped", [11341]], [[11294, 11294], "mapped", [11342]], [[11295, 11295], "mapped", [11343]], [[11296, 11296], "mapped", [11344]], [[11297, 11297], "mapped", [11345]], [[11298, 11298], "mapped", [11346]], [[11299, 11299], "mapped", [11347]], [[11300, 11300], "mapped", [11348]], [[11301, 11301], "mapped", [11349]], [[11302, 11302], "mapped", [11350]], [[11303, 11303], "mapped", [11351]], [[11304, 11304], "mapped", [11352]], [[11305, 11305], "mapped", [11353]], [[11306, 11306], "mapped", [11354]], [[11307, 11307], "mapped", [11355]], [[11308, 11308], "mapped", [11356]], [[11309, 11309], "mapped", [11357]], [[11310, 11310], "mapped", [11358]], [[11311, 11311], "disallowed"], [[11312, 11358], "valid"], [[11359, 11359], "disallowed"], [[11360, 11360], "mapped", [11361]], [[11361, 11361], "valid"], [[11362, 11362], "mapped", [619]], [[11363, 11363], "mapped", [7549]], [[11364, 11364], "mapped", [637]], [[11365, 11366], "valid"], [[11367, 11367], "mapped", [11368]], [[11368, 11368], "valid"], [[11369, 11369], "mapped", [11370]], [[11370, 11370], "valid"], [[11371, 11371], "mapped", [11372]], [[11372, 11372], "valid"], [[11373, 11373], "mapped", [593]], [[11374, 11374], "mapped", [625]], [[11375, 11375], "mapped", [592]], [[11376, 11376], "mapped", [594]], [[11377, 11377], "valid"], [[11378, 11378], "mapped", [11379]], [[11379, 11379], "valid"], [[11380, 11380], "valid"], [[11381, 11381], "mapped", [11382]], [[11382, 11383], "valid"], [[11384, 11387], "valid"], [[11388, 11388], "mapped", [106]], [[11389, 11389], "mapped", [118]], [[11390, 11390], "mapped", [575]], [[11391, 11391], "mapped", [576]], [[11392, 11392], "mapped", [11393]], [[11393, 11393], "valid"], [[11394, 11394], "mapped", [11395]], [[11395, 11395], "valid"], [[11396, 11396], "mapped", [11397]], [[11397, 11397], "valid"], [[11398, 11398], "mapped", [11399]], [[11399, 11399], "valid"], [[11400, 11400], "mapped", [11401]], [[11401, 11401], "valid"], [[11402, 11402], "mapped", [11403]], [[11403, 11403], "valid"], [[11404, 11404], "mapped", [11405]], [[11405, 11405], "valid"], [[11406, 11406], "mapped", [11407]], [[11407, 11407], "valid"], [[11408, 11408], "mapped", [11409]], [[11409, 11409], "valid"], [[11410, 11410], "mapped", [11411]], [[11411, 11411], "valid"], [[11412, 11412], "mapped", [11413]], [[11413, 11413], "valid"], [[11414, 11414], "mapped", [11415]], [[11415, 11415], "valid"], [[11416, 11416], "mapped", [11417]], [[11417, 11417], "valid"], [[11418, 11418], "mapped", [11419]], [[11419, 11419], "valid"], [[11420, 11420], "mapped", [11421]], [[11421, 11421], "valid"], [[11422, 11422], "mapped", [11423]], [[11423, 11423], "valid"], [[11424, 11424], "mapped", [11425]], [[11425, 11425], "valid"], [[11426, 11426], "mapped", [11427]], [[11427, 11427], "valid"], [[11428, 11428], "mapped", [11429]], [[11429, 11429], "valid"], [[11430, 11430], "mapped", [11431]], [[11431, 11431], "valid"], [[11432, 11432], "mapped", [11433]], [[11433, 11433], "valid"], [[11434, 11434], "mapped", [11435]], [[11435, 11435], "valid"], [[11436, 11436], "mapped", [11437]], [[11437, 11437], "valid"], [[11438, 11438], "mapped", [11439]], [[11439, 11439], "valid"], [[11440, 11440], "mapped", [11441]], [[11441, 11441], "valid"], [[11442, 11442], "mapped", [11443]], [[11443, 11443], "valid"], [[11444, 11444], "mapped", [11445]], [[11445, 11445], "valid"], [[11446, 11446], "mapped", [11447]], [[11447, 11447], "valid"], [[11448, 11448], "mapped", [11449]], [[11449, 11449], "valid"], [[11450, 11450], "mapped", [11451]], [[11451, 11451], "valid"], [[11452, 11452], "mapped", [11453]], [[11453, 11453], "valid"], [[11454, 11454], "mapped", [11455]], [[11455, 11455], "valid"], [[11456, 11456], "mapped", [11457]], [[11457, 11457], "valid"], [[11458, 11458], "mapped", [11459]], [[11459, 11459], "valid"], [[11460, 11460], "mapped", [11461]], [[11461, 11461], "valid"], [[11462, 11462], "mapped", [11463]], [[11463, 11463], "valid"], [[11464, 11464], "mapped", [11465]], [[11465, 11465], "valid"], [[11466, 11466], "mapped", [11467]], [[11467, 11467], "valid"], [[11468, 11468], "mapped", [11469]], [[11469, 11469], "valid"], [[11470, 11470], "mapped", [11471]], [[11471, 11471], "valid"], [[11472, 11472], "mapped", [11473]], [[11473, 11473], "valid"], [[11474, 11474], "mapped", [11475]], [[11475, 11475], "valid"], [[11476, 11476], "mapped", [11477]], [[11477, 11477], "valid"], [[11478, 11478], "mapped", [11479]], [[11479, 11479], "valid"], [[11480, 11480], "mapped", [11481]], [[11481, 11481], "valid"], [[11482, 11482], "mapped", [11483]], [[11483, 11483], "valid"], [[11484, 11484], "mapped", [11485]], [[11485, 11485], "valid"], [[11486, 11486], "mapped", [11487]], [[11487, 11487], "valid"], [[11488, 11488], "mapped", [11489]], [[11489, 11489], "valid"], [[11490, 11490], "mapped", [11491]], [[11491, 11492], "valid"], [[11493, 11498], "valid", [], "NV8"], [[11499, 11499], "mapped", [11500]], [[11500, 11500], "valid"], [[11501, 11501], "mapped", [11502]], [[11502, 11505], "valid"], [[11506, 11506], "mapped", [11507]], [[11507, 11507], "valid"], [[11508, 11512], "disallowed"], [[11513, 11519], "valid", [], "NV8"], [[11520, 11557], "valid"], [[11558, 11558], "disallowed"], [[11559, 11559], "valid"], [[11560, 11564], "disallowed"], [[11565, 11565], "valid"], [[11566, 11567], "disallowed"], [[11568, 11621], "valid"], [[11622, 11623], "valid"], [[11624, 11630], "disallowed"], [[11631, 11631], "mapped", [11617]], [[11632, 11632], "valid", [], "NV8"], [[11633, 11646], "disallowed"], [[11647, 11647], "valid"], [[11648, 11670], "valid"], [[11671, 11679], "disallowed"], [[11680, 11686], "valid"], [[11687, 11687], "disallowed"], [[11688, 11694], "valid"], [[11695, 11695], "disallowed"], [[11696, 11702], "valid"], [[11703, 11703], "disallowed"], [[11704, 11710], "valid"], [[11711, 11711], "disallowed"], [[11712, 11718], "valid"], [[11719, 11719], "disallowed"], [[11720, 11726], "valid"], [[11727, 11727], "disallowed"], [[11728, 11734], "valid"], [[11735, 11735], "disallowed"], [[11736, 11742], "valid"], [[11743, 11743], "disallowed"], [[11744, 11775], "valid"], [[11776, 11799], "valid", [], "NV8"], [[11800, 11803], "valid", [], "NV8"], [[11804, 11805], "valid", [], "NV8"], [[11806, 11822], "valid", [], "NV8"], [[11823, 11823], "valid"], [[11824, 11824], "valid", [], "NV8"], [[11825, 11825], "valid", [], "NV8"], [[11826, 11835], "valid", [], "NV8"], [[11836, 11842], "valid", [], "NV8"], [[11843, 11903], "disallowed"], [[11904, 11929], "valid", [], "NV8"], [[11930, 11930], "disallowed"], [[11931, 11934], "valid", [], "NV8"], [[11935, 11935], "mapped", [27597]], [[11936, 12018], "valid", [], "NV8"], [[12019, 12019], "mapped", [40863]], [[12020, 12031], "disallowed"], [[12032, 12032], "mapped", [19968]], [[12033, 12033], "mapped", [20008]], [[12034, 12034], "mapped", [20022]], [[12035, 12035], "mapped", [20031]], [[12036, 12036], "mapped", [20057]], [[12037, 12037], "mapped", [20101]], [[12038, 12038], "mapped", [20108]], [[12039, 12039], "mapped", [20128]], [[12040, 12040], "mapped", [20154]], [[12041, 12041], "mapped", [20799]], [[12042, 12042], "mapped", [20837]], [[12043, 12043], "mapped", [20843]], [[12044, 12044], "mapped", [20866]], [[12045, 12045], "mapped", [20886]], [[12046, 12046], "mapped", [20907]], [[12047, 12047], "mapped", [20960]], [[12048, 12048], "mapped", [20981]], [[12049, 12049], "mapped", [20992]], [[12050, 12050], "mapped", [21147]], [[12051, 12051], "mapped", [21241]], [[12052, 12052], "mapped", [21269]], [[12053, 12053], "mapped", [21274]], [[12054, 12054], "mapped", [21304]], [[12055, 12055], "mapped", [21313]], [[12056, 12056], "mapped", [21340]], [[12057, 12057], "mapped", [21353]], [[12058, 12058], "mapped", [21378]], [[12059, 12059], "mapped", [21430]], [[12060, 12060], "mapped", [21448]], [[12061, 12061], "mapped", [21475]], [[12062, 12062], "mapped", [22231]], [[12063, 12063], "mapped", [22303]], [[12064, 12064], "mapped", [22763]], [[12065, 12065], "mapped", [22786]], [[12066, 12066], "mapped", [22794]], [[12067, 12067], "mapped", [22805]], [[12068, 12068], "mapped", [22823]], [[12069, 12069], "mapped", [22899]], [[12070, 12070], "mapped", [23376]], [[12071, 12071], "mapped", [23424]], [[12072, 12072], "mapped", [23544]], [[12073, 12073], "mapped", [23567]], [[12074, 12074], "mapped", [23586]], [[12075, 12075], "mapped", [23608]], [[12076, 12076], "mapped", [23662]], [[12077, 12077], "mapped", [23665]], [[12078, 12078], "mapped", [24027]], [[12079, 12079], "mapped", [24037]], [[12080, 12080], "mapped", [24049]], [[12081, 12081], "mapped", [24062]], [[12082, 12082], "mapped", [24178]], [[12083, 12083], "mapped", [24186]], [[12084, 12084], "mapped", [24191]], [[12085, 12085], "mapped", [24308]], [[12086, 12086], "mapped", [24318]], [[12087, 12087], "mapped", [24331]], [[12088, 12088], "mapped", [24339]], [[12089, 12089], "mapped", [24400]], [[12090, 12090], "mapped", [24417]], [[12091, 12091], "mapped", [24435]], [[12092, 12092], "mapped", [24515]], [[12093, 12093], "mapped", [25096]], [[12094, 12094], "mapped", [25142]], [[12095, 12095], "mapped", [25163]], [[12096, 12096], "mapped", [25903]], [[12097, 12097], "mapped", [25908]], [[12098, 12098], "mapped", [25991]], [[12099, 12099], "mapped", [26007]], [[12100, 12100], "mapped", [26020]], [[12101, 12101], "mapped", [26041]], [[12102, 12102], "mapped", [26080]], [[12103, 12103], "mapped", [26085]], [[12104, 12104], "mapped", [26352]], [[12105, 12105], "mapped", [26376]], [[12106, 12106], "mapped", [26408]], [[12107, 12107], "mapped", [27424]], [[12108, 12108], "mapped", [27490]], [[12109, 12109], "mapped", [27513]], [[12110, 12110], "mapped", [27571]], [[12111, 12111], "mapped", [27595]], [[12112, 12112], "mapped", [27604]], [[12113, 12113], "mapped", [27611]], [[12114, 12114], "mapped", [27663]], [[12115, 12115], "mapped", [27668]], [[12116, 12116], "mapped", [27700]], [[12117, 12117], "mapped", [28779]], [[12118, 12118], "mapped", [29226]], [[12119, 12119], "mapped", [29238]], [[12120, 12120], "mapped", [29243]], [[12121, 12121], "mapped", [29247]], [[12122, 12122], "mapped", [29255]], [[12123, 12123], "mapped", [29273]], [[12124, 12124], "mapped", [29275]], [[12125, 12125], "mapped", [29356]], [[12126, 12126], "mapped", [29572]], [[12127, 12127], "mapped", [29577]], [[12128, 12128], "mapped", [29916]], [[12129, 12129], "mapped", [29926]], [[12130, 12130], "mapped", [29976]], [[12131, 12131], "mapped", [29983]], [[12132, 12132], "mapped", [29992]], [[12133, 12133], "mapped", [30000]], [[12134, 12134], "mapped", [30091]], [[12135, 12135], "mapped", [30098]], [[12136, 12136], "mapped", [30326]], [[12137, 12137], "mapped", [30333]], [[12138, 12138], "mapped", [30382]], [[12139, 12139], "mapped", [30399]], [[12140, 12140], "mapped", [30446]], [[12141, 12141], "mapped", [30683]], [[12142, 12142], "mapped", [30690]], [[12143, 12143], "mapped", [30707]], [[12144, 12144], "mapped", [31034]], [[12145, 12145], "mapped", [31160]], [[12146, 12146], "mapped", [31166]], [[12147, 12147], "mapped", [31348]], [[12148, 12148], "mapped", [31435]], [[12149, 12149], "mapped", [31481]], [[12150, 12150], "mapped", [31859]], [[12151, 12151], "mapped", [31992]], [[12152, 12152], "mapped", [32566]], [[12153, 12153], "mapped", [32593]], [[12154, 12154], "mapped", [32650]], [[12155, 12155], "mapped", [32701]], [[12156, 12156], "mapped", [32769]], [[12157, 12157], "mapped", [32780]], [[12158, 12158], "mapped", [32786]], [[12159, 12159], "mapped", [32819]], [[12160, 12160], "mapped", [32895]], [[12161, 12161], "mapped", [32905]], [[12162, 12162], "mapped", [33251]], [[12163, 12163], "mapped", [33258]], [[12164, 12164], "mapped", [33267]], [[12165, 12165], "mapped", [33276]], [[12166, 12166], "mapped", [33292]], [[12167, 12167], "mapped", [33307]], [[12168, 12168], "mapped", [33311]], [[12169, 12169], "mapped", [33390]], [[12170, 12170], "mapped", [33394]], [[12171, 12171], "mapped", [33400]], [[12172, 12172], "mapped", [34381]], [[12173, 12173], "mapped", [34411]], [[12174, 12174], "mapped", [34880]], [[12175, 12175], "mapped", [34892]], [[12176, 12176], "mapped", [34915]], [[12177, 12177], "mapped", [35198]], [[12178, 12178], "mapped", [35211]], [[12179, 12179], "mapped", [35282]], [[12180, 12180], "mapped", [35328]], [[12181, 12181], "mapped", [35895]], [[12182, 12182], "mapped", [35910]], [[12183, 12183], "mapped", [35925]], [[12184, 12184], "mapped", [35960]], [[12185, 12185], "mapped", [35997]], [[12186, 12186], "mapped", [36196]], [[12187, 12187], "mapped", [36208]], [[12188, 12188], "mapped", [36275]], [[12189, 12189], "mapped", [36523]], [[12190, 12190], "mapped", [36554]], [[12191, 12191], "mapped", [36763]], [[12192, 12192], "mapped", [36784]], [[12193, 12193], "mapped", [36789]], [[12194, 12194], "mapped", [37009]], [[12195, 12195], "mapped", [37193]], [[12196, 12196], "mapped", [37318]], [[12197, 12197], "mapped", [37324]], [[12198, 12198], "mapped", [37329]], [[12199, 12199], "mapped", [38263]], [[12200, 12200], "mapped", [38272]], [[12201, 12201], "mapped", [38428]], [[12202, 12202], "mapped", [38582]], [[12203, 12203], "mapped", [38585]], [[12204, 12204], "mapped", [38632]], [[12205, 12205], "mapped", [38737]], [[12206, 12206], "mapped", [38750]], [[12207, 12207], "mapped", [38754]], [[12208, 12208], "mapped", [38761]], [[12209, 12209], "mapped", [38859]], [[12210, 12210], "mapped", [38893]], [[12211, 12211], "mapped", [38899]], [[12212, 12212], "mapped", [38913]], [[12213, 12213], "mapped", [39080]], [[12214, 12214], "mapped", [39131]], [[12215, 12215], "mapped", [39135]], [[12216, 12216], "mapped", [39318]], [[12217, 12217], "mapped", [39321]], [[12218, 12218], "mapped", [39340]], [[12219, 12219], "mapped", [39592]], [[12220, 12220], "mapped", [39640]], [[12221, 12221], "mapped", [39647]], [[12222, 12222], "mapped", [39717]], [[12223, 12223], "mapped", [39727]], [[12224, 12224], "mapped", [39730]], [[12225, 12225], "mapped", [39740]], [[12226, 12226], "mapped", [39770]], [[12227, 12227], "mapped", [40165]], [[12228, 12228], "mapped", [40565]], [[12229, 12229], "mapped", [40575]], [[12230, 12230], "mapped", [40613]], [[12231, 12231], "mapped", [40635]], [[12232, 12232], "mapped", [40643]], [[12233, 12233], "mapped", [40653]], [[12234, 12234], "mapped", [40657]], [[12235, 12235], "mapped", [40697]], [[12236, 12236], "mapped", [40701]], [[12237, 12237], "mapped", [40718]], [[12238, 12238], "mapped", [40723]], [[12239, 12239], "mapped", [40736]], [[12240, 12240], "mapped", [40763]], [[12241, 12241], "mapped", [40778]], [[12242, 12242], "mapped", [40786]], [[12243, 12243], "mapped", [40845]], [[12244, 12244], "mapped", [40860]], [[12245, 12245], "mapped", [40864]], [[12246, 12271], "disallowed"], [[12272, 12283], "disallowed"], [[12284, 12287], "disallowed"], [[12288, 12288], "disallowed_STD3_mapped", [32]], [[12289, 12289], "valid", [], "NV8"], [[12290, 12290], "mapped", [46]], [[12291, 12292], "valid", [], "NV8"], [[12293, 12295], "valid"], [[12296, 12329], "valid", [], "NV8"], [[12330, 12333], "valid"], [[12334, 12341], "valid", [], "NV8"], [[12342, 12342], "mapped", [12306]], [[12343, 12343], "valid", [], "NV8"], [[12344, 12344], "mapped", [21313]], [[12345, 12345], "mapped", [21316]], [[12346, 12346], "mapped", [21317]], [[12347, 12347], "valid", [], "NV8"], [[12348, 12348], "valid"], [[12349, 12349], "valid", [], "NV8"], [[12350, 12350], "valid", [], "NV8"], [[12351, 12351], "valid", [], "NV8"], [[12352, 12352], "disallowed"], [[12353, 12436], "valid"], [[12437, 12438], "valid"], [[12439, 12440], "disallowed"], [[12441, 12442], "valid"], [[12443, 12443], "disallowed_STD3_mapped", [32, 12441]], [[12444, 12444], "disallowed_STD3_mapped", [32, 12442]], [[12445, 12446], "valid"], [[12447, 12447], "mapped", [12424, 12426]], [[12448, 12448], "valid", [], "NV8"], [[12449, 12542], "valid"], [[12543, 12543], "mapped", [12467, 12488]], [[12544, 12548], "disallowed"], [[12549, 12588], "valid"], [[12589, 12589], "valid"], [[12590, 12592], "disallowed"], [[12593, 12593], "mapped", [4352]], [[12594, 12594], "mapped", [4353]], [[12595, 12595], "mapped", [4522]], [[12596, 12596], "mapped", [4354]], [[12597, 12597], "mapped", [4524]], [[12598, 12598], "mapped", [4525]], [[12599, 12599], "mapped", [4355]], [[12600, 12600], "mapped", [4356]], [[12601, 12601], "mapped", [4357]], [[12602, 12602], "mapped", [4528]], [[12603, 12603], "mapped", [4529]], [[12604, 12604], "mapped", [4530]], [[12605, 12605], "mapped", [4531]], [[12606, 12606], "mapped", [4532]], [[12607, 12607], "mapped", [4533]], [[12608, 12608], "mapped", [4378]], [[12609, 12609], "mapped", [4358]], [[12610, 12610], "mapped", [4359]], [[12611, 12611], "mapped", [4360]], [[12612, 12612], "mapped", [4385]], [[12613, 12613], "mapped", [4361]], [[12614, 12614], "mapped", [4362]], [[12615, 12615], "mapped", [4363]], [[12616, 12616], "mapped", [4364]], [[12617, 12617], "mapped", [4365]], [[12618, 12618], "mapped", [4366]], [[12619, 12619], "mapped", [4367]], [[12620, 12620], "mapped", [4368]], [[12621, 12621], "mapped", [4369]], [[12622, 12622], "mapped", [4370]], [[12623, 12623], "mapped", [4449]], [[12624, 12624], "mapped", [4450]], [[12625, 12625], "mapped", [4451]], [[12626, 12626], "mapped", [4452]], [[12627, 12627], "mapped", [4453]], [[12628, 12628], "mapped", [4454]], [[12629, 12629], "mapped", [4455]], [[12630, 12630], "mapped", [4456]], [[12631, 12631], "mapped", [4457]], [[12632, 12632], "mapped", [4458]], [[12633, 12633], "mapped", [4459]], [[12634, 12634], "mapped", [4460]], [[12635, 12635], "mapped", [4461]], [[12636, 12636], "mapped", [4462]], [[12637, 12637], "mapped", [4463]], [[12638, 12638], "mapped", [4464]], [[12639, 12639], "mapped", [4465]], [[12640, 12640], "mapped", [4466]], [[12641, 12641], "mapped", [4467]], [[12642, 12642], "mapped", [4468]], [[12643, 12643], "mapped", [4469]], [[12644, 12644], "disallowed"], [[12645, 12645], "mapped", [4372]], [[12646, 12646], "mapped", [4373]], [[12647, 12647], "mapped", [4551]], [[12648, 12648], "mapped", [4552]], [[12649, 12649], "mapped", [4556]], [[12650, 12650], "mapped", [4558]], [[12651, 12651], "mapped", [4563]], [[12652, 12652], "mapped", [4567]], [[12653, 12653], "mapped", [4569]], [[12654, 12654], "mapped", [4380]], [[12655, 12655], "mapped", [4573]], [[12656, 12656], "mapped", [4575]], [[12657, 12657], "mapped", [4381]], [[12658, 12658], "mapped", [4382]], [[12659, 12659], "mapped", [4384]], [[12660, 12660], "mapped", [4386]], [[12661, 12661], "mapped", [4387]], [[12662, 12662], "mapped", [4391]], [[12663, 12663], "mapped", [4393]], [[12664, 12664], "mapped", [4395]], [[12665, 12665], "mapped", [4396]], [[12666, 12666], "mapped", [4397]], [[12667, 12667], "mapped", [4398]], [[12668, 12668], "mapped", [4399]], [[12669, 12669], "mapped", [4402]], [[12670, 12670], "mapped", [4406]], [[12671, 12671], "mapped", [4416]], [[12672, 12672], "mapped", [4423]], [[12673, 12673], "mapped", [4428]], [[12674, 12674], "mapped", [4593]], [[12675, 12675], "mapped", [4594]], [[12676, 12676], "mapped", [4439]], [[12677, 12677], "mapped", [4440]], [[12678, 12678], "mapped", [4441]], [[12679, 12679], "mapped", [4484]], [[12680, 12680], "mapped", [4485]], [[12681, 12681], "mapped", [4488]], [[12682, 12682], "mapped", [4497]], [[12683, 12683], "mapped", [4498]], [[12684, 12684], "mapped", [4500]], [[12685, 12685], "mapped", [4510]], [[12686, 12686], "mapped", [4513]], [[12687, 12687], "disallowed"], [[12688, 12689], "valid", [], "NV8"], [[12690, 12690], "mapped", [19968]], [[12691, 12691], "mapped", [20108]], [[12692, 12692], "mapped", [19977]], [[12693, 12693], "mapped", [22235]], [[12694, 12694], "mapped", [19978]], [[12695, 12695], "mapped", [20013]], [[12696, 12696], "mapped", [19979]], [[12697, 12697], "mapped", [30002]], [[12698, 12698], "mapped", [20057]], [[12699, 12699], "mapped", [19993]], [[12700, 12700], "mapped", [19969]], [[12701, 12701], "mapped", [22825]], [[12702, 12702], "mapped", [22320]], [[12703, 12703], "mapped", [20154]], [[12704, 12727], "valid"], [[12728, 12730], "valid"], [[12731, 12735], "disallowed"], [[12736, 12751], "valid", [], "NV8"], [[12752, 12771], "valid", [], "NV8"], [[12772, 12783], "disallowed"], [[12784, 12799], "valid"], [[12800, 12800], "disallowed_STD3_mapped", [40, 4352, 41]], [[12801, 12801], "disallowed_STD3_mapped", [40, 4354, 41]], [[12802, 12802], "disallowed_STD3_mapped", [40, 4355, 41]], [[12803, 12803], "disallowed_STD3_mapped", [40, 4357, 41]], [[12804, 12804], "disallowed_STD3_mapped", [40, 4358, 41]], [[12805, 12805], "disallowed_STD3_mapped", [40, 4359, 41]], [[12806, 12806], "disallowed_STD3_mapped", [40, 4361, 41]], [[12807, 12807], "disallowed_STD3_mapped", [40, 4363, 41]], [[12808, 12808], "disallowed_STD3_mapped", [40, 4364, 41]], [[12809, 12809], "disallowed_STD3_mapped", [40, 4366, 41]], [[12810, 12810], "disallowed_STD3_mapped", [40, 4367, 41]], [[12811, 12811], "disallowed_STD3_mapped", [40, 4368, 41]], [[12812, 12812], "disallowed_STD3_mapped", [40, 4369, 41]], [[12813, 12813], "disallowed_STD3_mapped", [40, 4370, 41]], [[12814, 12814], "disallowed_STD3_mapped", [40, 44032, 41]], [[12815, 12815], "disallowed_STD3_mapped", [40, 45208, 41]], [[12816, 12816], "disallowed_STD3_mapped", [40, 45796, 41]], [[12817, 12817], "disallowed_STD3_mapped", [40, 46972, 41]], [[12818, 12818], "disallowed_STD3_mapped", [40, 47560, 41]], [[12819, 12819], "disallowed_STD3_mapped", [40, 48148, 41]], [[12820, 12820], "disallowed_STD3_mapped", [40, 49324, 41]], [[12821, 12821], "disallowed_STD3_mapped", [40, 50500, 41]], [[12822, 12822], "disallowed_STD3_mapped", [40, 51088, 41]], [[12823, 12823], "disallowed_STD3_mapped", [40, 52264, 41]], [[12824, 12824], "disallowed_STD3_mapped", [40, 52852, 41]], [[12825, 12825], "disallowed_STD3_mapped", [40, 53440, 41]], [[12826, 12826], "disallowed_STD3_mapped", [40, 54028, 41]], [[12827, 12827], "disallowed_STD3_mapped", [40, 54616, 41]], [[12828, 12828], "disallowed_STD3_mapped", [40, 51452, 41]], [[12829, 12829], "disallowed_STD3_mapped", [40, 50724, 51204, 41]], [[12830, 12830], "disallowed_STD3_mapped", [40, 50724, 54980, 41]], [[12831, 12831], "disallowed"], [[12832, 12832], "disallowed_STD3_mapped", [40, 19968, 41]], [[12833, 12833], "disallowed_STD3_mapped", [40, 20108, 41]], [[12834, 12834], "disallowed_STD3_mapped", [40, 19977, 41]], [[12835, 12835], "disallowed_STD3_mapped", [40, 22235, 41]], [[12836, 12836], "disallowed_STD3_mapped", [40, 20116, 41]], [[12837, 12837], "disallowed_STD3_mapped", [40, 20845, 41]], [[12838, 12838], "disallowed_STD3_mapped", [40, 19971, 41]], [[12839, 12839], "disallowed_STD3_mapped", [40, 20843, 41]], [[12840, 12840], "disallowed_STD3_mapped", [40, 20061, 41]], [[12841, 12841], "disallowed_STD3_mapped", [40, 21313, 41]], [[12842, 12842], "disallowed_STD3_mapped", [40, 26376, 41]], [[12843, 12843], "disallowed_STD3_mapped", [40, 28779, 41]], [[12844, 12844], "disallowed_STD3_mapped", [40, 27700, 41]], [[12845, 12845], "disallowed_STD3_mapped", [40, 26408, 41]], [[12846, 12846], "disallowed_STD3_mapped", [40, 37329, 41]], [[12847, 12847], "disallowed_STD3_mapped", [40, 22303, 41]], [[12848, 12848], "disallowed_STD3_mapped", [40, 26085, 41]], [[12849, 12849], "disallowed_STD3_mapped", [40, 26666, 41]], [[12850, 12850], "disallowed_STD3_mapped", [40, 26377, 41]], [[12851, 12851], "disallowed_STD3_mapped", [40, 31038, 41]], [[12852, 12852], "disallowed_STD3_mapped", [40, 21517, 41]], [[12853, 12853], "disallowed_STD3_mapped", [40, 29305, 41]], [[12854, 12854], "disallowed_STD3_mapped", [40, 36001, 41]], [[12855, 12855], "disallowed_STD3_mapped", [40, 31069, 41]], [[12856, 12856], "disallowed_STD3_mapped", [40, 21172, 41]], [[12857, 12857], "disallowed_STD3_mapped", [40, 20195, 41]], [[12858, 12858], "disallowed_STD3_mapped", [40, 21628, 41]], [[12859, 12859], "disallowed_STD3_mapped", [40, 23398, 41]], [[12860, 12860], "disallowed_STD3_mapped", [40, 30435, 41]], [[12861, 12861], "disallowed_STD3_mapped", [40, 20225, 41]], [[12862, 12862], "disallowed_STD3_mapped", [40, 36039, 41]], [[12863, 12863], "disallowed_STD3_mapped", [40, 21332, 41]], [[12864, 12864], "disallowed_STD3_mapped", [40, 31085, 41]], [[12865, 12865], "disallowed_STD3_mapped", [40, 20241, 41]], [[12866, 12866], "disallowed_STD3_mapped", [40, 33258, 41]], [[12867, 12867], "disallowed_STD3_mapped", [40, 33267, 41]], [[12868, 12868], "mapped", [21839]], [[12869, 12869], "mapped", [24188]], [[12870, 12870], "mapped", [25991]], [[12871, 12871], "mapped", [31631]], [[12872, 12879], "valid", [], "NV8"], [[12880, 12880], "mapped", [112, 116, 101]], [[12881, 12881], "mapped", [50, 49]], [[12882, 12882], "mapped", [50, 50]], [[12883, 12883], "mapped", [50, 51]], [[12884, 12884], "mapped", [50, 52]], [[12885, 12885], "mapped", [50, 53]], [[12886, 12886], "mapped", [50, 54]], [[12887, 12887], "mapped", [50, 55]], [[12888, 12888], "mapped", [50, 56]], [[12889, 12889], "mapped", [50, 57]], [[12890, 12890], "mapped", [51, 48]], [[12891, 12891], "mapped", [51, 49]], [[12892, 12892], "mapped", [51, 50]], [[12893, 12893], "mapped", [51, 51]], [[12894, 12894], "mapped", [51, 52]], [[12895, 12895], "mapped", [51, 53]], [[12896, 12896], "mapped", [4352]], [[12897, 12897], "mapped", [4354]], [[12898, 12898], "mapped", [4355]], [[12899, 12899], "mapped", [4357]], [[12900, 12900], "mapped", [4358]], [[12901, 12901], "mapped", [4359]], [[12902, 12902], "mapped", [4361]], [[12903, 12903], "mapped", [4363]], [[12904, 12904], "mapped", [4364]], [[12905, 12905], "mapped", [4366]], [[12906, 12906], "mapped", [4367]], [[12907, 12907], "mapped", [4368]], [[12908, 12908], "mapped", [4369]], [[12909, 12909], "mapped", [4370]], [[12910, 12910], "mapped", [44032]], [[12911, 12911], "mapped", [45208]], [[12912, 12912], "mapped", [45796]], [[12913, 12913], "mapped", [46972]], [[12914, 12914], "mapped", [47560]], [[12915, 12915], "mapped", [48148]], [[12916, 12916], "mapped", [49324]], [[12917, 12917], "mapped", [50500]], [[12918, 12918], "mapped", [51088]], [[12919, 12919], "mapped", [52264]], [[12920, 12920], "mapped", [52852]], [[12921, 12921], "mapped", [53440]], [[12922, 12922], "mapped", [54028]], [[12923, 12923], "mapped", [54616]], [[12924, 12924], "mapped", [52280, 44256]], [[12925, 12925], "mapped", [51452, 51032]], [[12926, 12926], "mapped", [50864]], [[12927, 12927], "valid", [], "NV8"], [[12928, 12928], "mapped", [19968]], [[12929, 12929], "mapped", [20108]], [[12930, 12930], "mapped", [19977]], [[12931, 12931], "mapped", [22235]], [[12932, 12932], "mapped", [20116]], [[12933, 12933], "mapped", [20845]], [[12934, 12934], "mapped", [19971]], [[12935, 12935], "mapped", [20843]], [[12936, 12936], "mapped", [20061]], [[12937, 12937], "mapped", [21313]], [[12938, 12938], "mapped", [26376]], [[12939, 12939], "mapped", [28779]], [[12940, 12940], "mapped", [27700]], [[12941, 12941], "mapped", [26408]], [[12942, 12942], "mapped", [37329]], [[12943, 12943], "mapped", [22303]], [[12944, 12944], "mapped", [26085]], [[12945, 12945], "mapped", [26666]], [[12946, 12946], "mapped", [26377]], [[12947, 12947], "mapped", [31038]], [[12948, 12948], "mapped", [21517]], [[12949, 12949], "mapped", [29305]], [[12950, 12950], "mapped", [36001]], [[12951, 12951], "mapped", [31069]], [[12952, 12952], "mapped", [21172]], [[12953, 12953], "mapped", [31192]], [[12954, 12954], "mapped", [30007]], [[12955, 12955], "mapped", [22899]], [[12956, 12956], "mapped", [36969]], [[12957, 12957], "mapped", [20778]], [[12958, 12958], "mapped", [21360]], [[12959, 12959], "mapped", [27880]], [[12960, 12960], "mapped", [38917]], [[12961, 12961], "mapped", [20241]], [[12962, 12962], "mapped", [20889]], [[12963, 12963], "mapped", [27491]], [[12964, 12964], "mapped", [19978]], [[12965, 12965], "mapped", [20013]], [[12966, 12966], "mapped", [19979]], [[12967, 12967], "mapped", [24038]], [[12968, 12968], "mapped", [21491]], [[12969, 12969], "mapped", [21307]], [[12970, 12970], "mapped", [23447]], [[12971, 12971], "mapped", [23398]], [[12972, 12972], "mapped", [30435]], [[12973, 12973], "mapped", [20225]], [[12974, 12974], "mapped", [36039]], [[12975, 12975], "mapped", [21332]], [[12976, 12976], "mapped", [22812]], [[12977, 12977], "mapped", [51, 54]], [[12978, 12978], "mapped", [51, 55]], [[12979, 12979], "mapped", [51, 56]], [[12980, 12980], "mapped", [51, 57]], [[12981, 12981], "mapped", [52, 48]], [[12982, 12982], "mapped", [52, 49]], [[12983, 12983], "mapped", [52, 50]], [[12984, 12984], "mapped", [52, 51]], [[12985, 12985], "mapped", [52, 52]], [[12986, 12986], "mapped", [52, 53]], [[12987, 12987], "mapped", [52, 54]], [[12988, 12988], "mapped", [52, 55]], [[12989, 12989], "mapped", [52, 56]], [[12990, 12990], "mapped", [52, 57]], [[12991, 12991], "mapped", [53, 48]], [[12992, 12992], "mapped", [49, 26376]], [[12993, 12993], "mapped", [50, 26376]], [[12994, 12994], "mapped", [51, 26376]], [[12995, 12995], "mapped", [52, 26376]], [[12996, 12996], "mapped", [53, 26376]], [[12997, 12997], "mapped", [54, 26376]], [[12998, 12998], "mapped", [55, 26376]], [[12999, 12999], "mapped", [56, 26376]], [[13000, 13000], "mapped", [57, 26376]], [[13001, 13001], "mapped", [49, 48, 26376]], [[13002, 13002], "mapped", [49, 49, 26376]], [[13003, 13003], "mapped", [49, 50, 26376]], [[13004, 13004], "mapped", [104, 103]], [[13005, 13005], "mapped", [101, 114, 103]], [[13006, 13006], "mapped", [101, 118]], [[13007, 13007], "mapped", [108, 116, 100]], [[13008, 13008], "mapped", [12450]], [[13009, 13009], "mapped", [12452]], [[13010, 13010], "mapped", [12454]], [[13011, 13011], "mapped", [12456]], [[13012, 13012], "mapped", [12458]], [[13013, 13013], "mapped", [12459]], [[13014, 13014], "mapped", [12461]], [[13015, 13015], "mapped", [12463]], [[13016, 13016], "mapped", [12465]], [[13017, 13017], "mapped", [12467]], [[13018, 13018], "mapped", [12469]], [[13019, 13019], "mapped", [12471]], [[13020, 13020], "mapped", [12473]], [[13021, 13021], "mapped", [12475]], [[13022, 13022], "mapped", [12477]], [[13023, 13023], "mapped", [12479]], [[13024, 13024], "mapped", [12481]], [[13025, 13025], "mapped", [12484]], [[13026, 13026], "mapped", [12486]], [[13027, 13027], "mapped", [12488]], [[13028, 13028], "mapped", [12490]], [[13029, 13029], "mapped", [12491]], [[13030, 13030], "mapped", [12492]], [[13031, 13031], "mapped", [12493]], [[13032, 13032], "mapped", [12494]], [[13033, 13033], "mapped", [12495]], [[13034, 13034], "mapped", [12498]], [[13035, 13035], "mapped", [12501]], [[13036, 13036], "mapped", [12504]], [[13037, 13037], "mapped", [12507]], [[13038, 13038], "mapped", [12510]], [[13039, 13039], "mapped", [12511]], [[13040, 13040], "mapped", [12512]], [[13041, 13041], "mapped", [12513]], [[13042, 13042], "mapped", [12514]], [[13043, 13043], "mapped", [12516]], [[13044, 13044], "mapped", [12518]], [[13045, 13045], "mapped", [12520]], [[13046, 13046], "mapped", [12521]], [[13047, 13047], "mapped", [12522]], [[13048, 13048], "mapped", [12523]], [[13049, 13049], "mapped", [12524]], [[13050, 13050], "mapped", [12525]], [[13051, 13051], "mapped", [12527]], [[13052, 13052], "mapped", [12528]], [[13053, 13053], "mapped", [12529]], [[13054, 13054], "mapped", [12530]], [[13055, 13055], "disallowed"], [[13056, 13056], "mapped", [12450, 12497, 12540, 12488]], [[13057, 13057], "mapped", [12450, 12523, 12501, 12449]], [[13058, 13058], "mapped", [12450, 12531, 12506, 12450]], [[13059, 13059], "mapped", [12450, 12540, 12523]], [[13060, 13060], "mapped", [12452, 12491, 12531, 12464]], [[13061, 13061], "mapped", [12452, 12531, 12481]], [[13062, 13062], "mapped", [12454, 12457, 12531]], [[13063, 13063], "mapped", [12456, 12473, 12463, 12540, 12489]], [[13064, 13064], "mapped", [12456, 12540, 12459, 12540]], [[13065, 13065], "mapped", [12458, 12531, 12473]], [[13066, 13066], "mapped", [12458, 12540, 12512]], [[13067, 13067], "mapped", [12459, 12452, 12522]], [[13068, 13068], "mapped", [12459, 12521, 12483, 12488]], [[13069, 13069], "mapped", [12459, 12525, 12522, 12540]], [[13070, 13070], "mapped", [12460, 12525, 12531]], [[13071, 13071], "mapped", [12460, 12531, 12510]], [[13072, 13072], "mapped", [12462, 12460]], [[13073, 13073], "mapped", [12462, 12491, 12540]], [[13074, 13074], "mapped", [12461, 12517, 12522, 12540]], [[13075, 13075], "mapped", [12462, 12523, 12480, 12540]], [[13076, 13076], "mapped", [12461, 12525]], [[13077, 13077], "mapped", [12461, 12525, 12464, 12521, 12512]], [[13078, 13078], "mapped", [12461, 12525, 12513, 12540, 12488, 12523]], [[13079, 13079], "mapped", [12461, 12525, 12527, 12483, 12488]], [[13080, 13080], "mapped", [12464, 12521, 12512]], [[13081, 13081], "mapped", [12464, 12521, 12512, 12488, 12531]], [[13082, 13082], "mapped", [12463, 12523, 12476, 12452, 12525]], [[13083, 13083], "mapped", [12463, 12525, 12540, 12493]], [[13084, 13084], "mapped", [12465, 12540, 12473]], [[13085, 13085], "mapped", [12467, 12523, 12490]], [[13086, 13086], "mapped", [12467, 12540, 12509]], [[13087, 13087], "mapped", [12469, 12452, 12463, 12523]], [[13088, 13088], "mapped", [12469, 12531, 12481, 12540, 12512]], [[13089, 13089], "mapped", [12471, 12522, 12531, 12464]], [[13090, 13090], "mapped", [12475, 12531, 12481]], [[13091, 13091], "mapped", [12475, 12531, 12488]], [[13092, 13092], "mapped", [12480, 12540, 12473]], [[13093, 13093], "mapped", [12487, 12471]], [[13094, 13094], "mapped", [12489, 12523]], [[13095, 13095], "mapped", [12488, 12531]], [[13096, 13096], "mapped", [12490, 12494]], [[13097, 13097], "mapped", [12494, 12483, 12488]], [[13098, 13098], "mapped", [12495, 12452, 12484]], [[13099, 13099], "mapped", [12497, 12540, 12475, 12531, 12488]], [[13100, 13100], "mapped", [12497, 12540, 12484]], [[13101, 13101], "mapped", [12496, 12540, 12524, 12523]], [[13102, 13102], "mapped", [12500, 12450, 12473, 12488, 12523]], [[13103, 13103], "mapped", [12500, 12463, 12523]], [[13104, 13104], "mapped", [12500, 12467]], [[13105, 13105], "mapped", [12499, 12523]], [[13106, 13106], "mapped", [12501, 12449, 12521, 12483, 12489]], [[13107, 13107], "mapped", [12501, 12451, 12540, 12488]], [[13108, 13108], "mapped", [12502, 12483, 12471, 12455, 12523]], [[13109, 13109], "mapped", [12501, 12521, 12531]], [[13110, 13110], "mapped", [12504, 12463, 12479, 12540, 12523]], [[13111, 13111], "mapped", [12506, 12477]], [[13112, 13112], "mapped", [12506, 12491, 12498]], [[13113, 13113], "mapped", [12504, 12523, 12484]], [[13114, 13114], "mapped", [12506, 12531, 12473]], [[13115, 13115], "mapped", [12506, 12540, 12472]], [[13116, 13116], "mapped", [12505, 12540, 12479]], [[13117, 13117], "mapped", [12509, 12452, 12531, 12488]], [[13118, 13118], "mapped", [12508, 12523, 12488]], [[13119, 13119], "mapped", [12507, 12531]], [[13120, 13120], "mapped", [12509, 12531, 12489]], [[13121, 13121], "mapped", [12507, 12540, 12523]], [[13122, 13122], "mapped", [12507, 12540, 12531]], [[13123, 13123], "mapped", [12510, 12452, 12463, 12525]], [[13124, 13124], "mapped", [12510, 12452, 12523]], [[13125, 13125], "mapped", [12510, 12483, 12495]], [[13126, 13126], "mapped", [12510, 12523, 12463]], [[13127, 13127], "mapped", [12510, 12531, 12471, 12519, 12531]], [[13128, 13128], "mapped", [12511, 12463, 12525, 12531]], [[13129, 13129], "mapped", [12511, 12522]], [[13130, 13130], "mapped", [12511, 12522, 12496, 12540, 12523]], [[13131, 13131], "mapped", [12513, 12460]], [[13132, 13132], "mapped", [12513, 12460, 12488, 12531]], [[13133, 13133], "mapped", [12513, 12540, 12488, 12523]], [[13134, 13134], "mapped", [12516, 12540, 12489]], [[13135, 13135], "mapped", [12516, 12540, 12523]], [[13136, 13136], "mapped", [12518, 12450, 12531]], [[13137, 13137], "mapped", [12522, 12483, 12488, 12523]], [[13138, 13138], "mapped", [12522, 12521]], [[13139, 13139], "mapped", [12523, 12500, 12540]], [[13140, 13140], "mapped", [12523, 12540, 12502, 12523]], [[13141, 13141], "mapped", [12524, 12512]], [[13142, 13142], "mapped", [12524, 12531, 12488, 12466, 12531]], [[13143, 13143], "mapped", [12527, 12483, 12488]], [[13144, 13144], "mapped", [48, 28857]], [[13145, 13145], "mapped", [49, 28857]], [[13146, 13146], "mapped", [50, 28857]], [[13147, 13147], "mapped", [51, 28857]], [[13148, 13148], "mapped", [52, 28857]], [[13149, 13149], "mapped", [53, 28857]], [[13150, 13150], "mapped", [54, 28857]], [[13151, 13151], "mapped", [55, 28857]], [[13152, 13152], "mapped", [56, 28857]], [[13153, 13153], "mapped", [57, 28857]], [[13154, 13154], "mapped", [49, 48, 28857]], [[13155, 13155], "mapped", [49, 49, 28857]], [[13156, 13156], "mapped", [49, 50, 28857]], [[13157, 13157], "mapped", [49, 51, 28857]], [[13158, 13158], "mapped", [49, 52, 28857]], [[13159, 13159], "mapped", [49, 53, 28857]], [[13160, 13160], "mapped", [49, 54, 28857]], [[13161, 13161], "mapped", [49, 55, 28857]], [[13162, 13162], "mapped", [49, 56, 28857]], [[13163, 13163], "mapped", [49, 57, 28857]], [[13164, 13164], "mapped", [50, 48, 28857]], [[13165, 13165], "mapped", [50, 49, 28857]], [[13166, 13166], "mapped", [50, 50, 28857]], [[13167, 13167], "mapped", [50, 51, 28857]], [[13168, 13168], "mapped", [50, 52, 28857]], [[13169, 13169], "mapped", [104, 112, 97]], [[13170, 13170], "mapped", [100, 97]], [[13171, 13171], "mapped", [97, 117]], [[13172, 13172], "mapped", [98, 97, 114]], [[13173, 13173], "mapped", [111, 118]], [[13174, 13174], "mapped", [112, 99]], [[13175, 13175], "mapped", [100, 109]], [[13176, 13176], "mapped", [100, 109, 50]], [[13177, 13177], "mapped", [100, 109, 51]], [[13178, 13178], "mapped", [105, 117]], [[13179, 13179], "mapped", [24179, 25104]], [[13180, 13180], "mapped", [26157, 21644]], [[13181, 13181], "mapped", [22823, 27491]], [[13182, 13182], "mapped", [26126, 27835]], [[13183, 13183], "mapped", [26666, 24335, 20250, 31038]], [[13184, 13184], "mapped", [112, 97]], [[13185, 13185], "mapped", [110, 97]], [[13186, 13186], "mapped", [956, 97]], [[13187, 13187], "mapped", [109, 97]], [[13188, 13188], "mapped", [107, 97]], [[13189, 13189], "mapped", [107, 98]], [[13190, 13190], "mapped", [109, 98]], [[13191, 13191], "mapped", [103, 98]], [[13192, 13192], "mapped", [99, 97, 108]], [[13193, 13193], "mapped", [107, 99, 97, 108]], [[13194, 13194], "mapped", [112, 102]], [[13195, 13195], "mapped", [110, 102]], [[13196, 13196], "mapped", [956, 102]], [[13197, 13197], "mapped", [956, 103]], [[13198, 13198], "mapped", [109, 103]], [[13199, 13199], "mapped", [107, 103]], [[13200, 13200], "mapped", [104, 122]], [[13201, 13201], "mapped", [107, 104, 122]], [[13202, 13202], "mapped", [109, 104, 122]], [[13203, 13203], "mapped", [103, 104, 122]], [[13204, 13204], "mapped", [116, 104, 122]], [[13205, 13205], "mapped", [956, 108]], [[13206, 13206], "mapped", [109, 108]], [[13207, 13207], "mapped", [100, 108]], [[13208, 13208], "mapped", [107, 108]], [[13209, 13209], "mapped", [102, 109]], [[13210, 13210], "mapped", [110, 109]], [[13211, 13211], "mapped", [956, 109]], [[13212, 13212], "mapped", [109, 109]], [[13213, 13213], "mapped", [99, 109]], [[13214, 13214], "mapped", [107, 109]], [[13215, 13215], "mapped", [109, 109, 50]], [[13216, 13216], "mapped", [99, 109, 50]], [[13217, 13217], "mapped", [109, 50]], [[13218, 13218], "mapped", [107, 109, 50]], [[13219, 13219], "mapped", [109, 109, 51]], [[13220, 13220], "mapped", [99, 109, 51]], [[13221, 13221], "mapped", [109, 51]], [[13222, 13222], "mapped", [107, 109, 51]], [[13223, 13223], "mapped", [109, 8725, 115]], [[13224, 13224], "mapped", [109, 8725, 115, 50]], [[13225, 13225], "mapped", [112, 97]], [[13226, 13226], "mapped", [107, 112, 97]], [[13227, 13227], "mapped", [109, 112, 97]], [[13228, 13228], "mapped", [103, 112, 97]], [[13229, 13229], "mapped", [114, 97, 100]], [[13230, 13230], "mapped", [114, 97, 100, 8725, 115]], [[13231, 13231], "mapped", [114, 97, 100, 8725, 115, 50]], [[13232, 13232], "mapped", [112, 115]], [[13233, 13233], "mapped", [110, 115]], [[13234, 13234], "mapped", [956, 115]], [[13235, 13235], "mapped", [109, 115]], [[13236, 13236], "mapped", [112, 118]], [[13237, 13237], "mapped", [110, 118]], [[13238, 13238], "mapped", [956, 118]], [[13239, 13239], "mapped", [109, 118]], [[13240, 13240], "mapped", [107, 118]], [[13241, 13241], "mapped", [109, 118]], [[13242, 13242], "mapped", [112, 119]], [[13243, 13243], "mapped", [110, 119]], [[13244, 13244], "mapped", [956, 119]], [[13245, 13245], "mapped", [109, 119]], [[13246, 13246], "mapped", [107, 119]], [[13247, 13247], "mapped", [109, 119]], [[13248, 13248], "mapped", [107, 969]], [[13249, 13249], "mapped", [109, 969]], [[13250, 13250], "disallowed"], [[13251, 13251], "mapped", [98, 113]], [[13252, 13252], "mapped", [99, 99]], [[13253, 13253], "mapped", [99, 100]], [[13254, 13254], "mapped", [99, 8725, 107, 103]], [[13255, 13255], "disallowed"], [[13256, 13256], "mapped", [100, 98]], [[13257, 13257], "mapped", [103, 121]], [[13258, 13258], "mapped", [104, 97]], [[13259, 13259], "mapped", [104, 112]], [[13260, 13260], "mapped", [105, 110]], [[13261, 13261], "mapped", [107, 107]], [[13262, 13262], "mapped", [107, 109]], [[13263, 13263], "mapped", [107, 116]], [[13264, 13264], "mapped", [108, 109]], [[13265, 13265], "mapped", [108, 110]], [[13266, 13266], "mapped", [108, 111, 103]], [[13267, 13267], "mapped", [108, 120]], [[13268, 13268], "mapped", [109, 98]], [[13269, 13269], "mapped", [109, 105, 108]], [[13270, 13270], "mapped", [109, 111, 108]], [[13271, 13271], "mapped", [112, 104]], [[13272, 13272], "disallowed"], [[13273, 13273], "mapped", [112, 112, 109]], [[13274, 13274], "mapped", [112, 114]], [[13275, 13275], "mapped", [115, 114]], [[13276, 13276], "mapped", [115, 118]], [[13277, 13277], "mapped", [119, 98]], [[13278, 13278], "mapped", [118, 8725, 109]], [[13279, 13279], "mapped", [97, 8725, 109]], [[13280, 13280], "mapped", [49, 26085]], [[13281, 13281], "mapped", [50, 26085]], [[13282, 13282], "mapped", [51, 26085]], [[13283, 13283], "mapped", [52, 26085]], [[13284, 13284], "mapped", [53, 26085]], [[13285, 13285], "mapped", [54, 26085]], [[13286, 13286], "mapped", [55, 26085]], [[13287, 13287], "mapped", [56, 26085]], [[13288, 13288], "mapped", [57, 26085]], [[13289, 13289], "mapped", [49, 48, 26085]], [[13290, 13290], "mapped", [49, 49, 26085]], [[13291, 13291], "mapped", [49, 50, 26085]], [[13292, 13292], "mapped", [49, 51, 26085]], [[13293, 13293], "mapped", [49, 52, 26085]], [[13294, 13294], "mapped", [49, 53, 26085]], [[13295, 13295], "mapped", [49, 54, 26085]], [[13296, 13296], "mapped", [49, 55, 26085]], [[13297, 13297], "mapped", [49, 56, 26085]], [[13298, 13298], "mapped", [49, 57, 26085]], [[13299, 13299], "mapped", [50, 48, 26085]], [[13300, 13300], "mapped", [50, 49, 26085]], [[13301, 13301], "mapped", [50, 50, 26085]], [[13302, 13302], "mapped", [50, 51, 26085]], [[13303, 13303], "mapped", [50, 52, 26085]], [[13304, 13304], "mapped", [50, 53, 26085]], [[13305, 13305], "mapped", [50, 54, 26085]], [[13306, 13306], "mapped", [50, 55, 26085]], [[13307, 13307], "mapped", [50, 56, 26085]], [[13308, 13308], "mapped", [50, 57, 26085]], [[13309, 13309], "mapped", [51, 48, 26085]], [[13310, 13310], "mapped", [51, 49, 26085]], [[13311, 13311], "mapped", [103, 97, 108]], [[13312, 19893], "valid"], [[19894, 19903], "disallowed"], [[19904, 19967], "valid", [], "NV8"], [[19968, 40869], "valid"], [[40870, 40891], "valid"], [[40892, 40899], "valid"], [[40900, 40907], "valid"], [[40908, 40908], "valid"], [[40909, 40917], "valid"], [[40918, 40959], "disallowed"], [[40960, 42124], "valid"], [[42125, 42127], "disallowed"], [[42128, 42145], "valid", [], "NV8"], [[42146, 42147], "valid", [], "NV8"], [[42148, 42163], "valid", [], "NV8"], [[42164, 42164], "valid", [], "NV8"], [[42165, 42176], "valid", [], "NV8"], [[42177, 42177], "valid", [], "NV8"], [[42178, 42180], "valid", [], "NV8"], [[42181, 42181], "valid", [], "NV8"], [[42182, 42182], "valid", [], "NV8"], [[42183, 42191], "disallowed"], [[42192, 42237], "valid"], [[42238, 42239], "valid", [], "NV8"], [[42240, 42508], "valid"], [[42509, 42511], "valid", [], "NV8"], [[42512, 42539], "valid"], [[42540, 42559], "disallowed"], [[42560, 42560], "mapped", [42561]], [[42561, 42561], "valid"], [[42562, 42562], "mapped", [42563]], [[42563, 42563], "valid"], [[42564, 42564], "mapped", [42565]], [[42565, 42565], "valid"], [[42566, 42566], "mapped", [42567]], [[42567, 42567], "valid"], [[42568, 42568], "mapped", [42569]], [[42569, 42569], "valid"], [[42570, 42570], "mapped", [42571]], [[42571, 42571], "valid"], [[42572, 42572], "mapped", [42573]], [[42573, 42573], "valid"], [[42574, 42574], "mapped", [42575]], [[42575, 42575], "valid"], [[42576, 42576], "mapped", [42577]], [[42577, 42577], "valid"], [[42578, 42578], "mapped", [42579]], [[42579, 42579], "valid"], [[42580, 42580], "mapped", [42581]], [[42581, 42581], "valid"], [[42582, 42582], "mapped", [42583]], [[42583, 42583], "valid"], [[42584, 42584], "mapped", [42585]], [[42585, 42585], "valid"], [[42586, 42586], "mapped", [42587]], [[42587, 42587], "valid"], [[42588, 42588], "mapped", [42589]], [[42589, 42589], "valid"], [[42590, 42590], "mapped", [42591]], [[42591, 42591], "valid"], [[42592, 42592], "mapped", [42593]], [[42593, 42593], "valid"], [[42594, 42594], "mapped", [42595]], [[42595, 42595], "valid"], [[42596, 42596], "mapped", [42597]], [[42597, 42597], "valid"], [[42598, 42598], "mapped", [42599]], [[42599, 42599], "valid"], [[42600, 42600], "mapped", [42601]], [[42601, 42601], "valid"], [[42602, 42602], "mapped", [42603]], [[42603, 42603], "valid"], [[42604, 42604], "mapped", [42605]], [[42605, 42607], "valid"], [[42608, 42611], "valid", [], "NV8"], [[42612, 42619], "valid"], [[42620, 42621], "valid"], [[42622, 42622], "valid", [], "NV8"], [[42623, 42623], "valid"], [[42624, 42624], "mapped", [42625]], [[42625, 42625], "valid"], [[42626, 42626], "mapped", [42627]], [[42627, 42627], "valid"], [[42628, 42628], "mapped", [42629]], [[42629, 42629], "valid"], [[42630, 42630], "mapped", [42631]], [[42631, 42631], "valid"], [[42632, 42632], "mapped", [42633]], [[42633, 42633], "valid"], [[42634, 42634], "mapped", [42635]], [[42635, 42635], "valid"], [[42636, 42636], "mapped", [42637]], [[42637, 42637], "valid"], [[42638, 42638], "mapped", [42639]], [[42639, 42639], "valid"], [[42640, 42640], "mapped", [42641]], [[42641, 42641], "valid"], [[42642, 42642], "mapped", [42643]], [[42643, 42643], "valid"], [[42644, 42644], "mapped", [42645]], [[42645, 42645], "valid"], [[42646, 42646], "mapped", [42647]], [[42647, 42647], "valid"], [[42648, 42648], "mapped", [42649]], [[42649, 42649], "valid"], [[42650, 42650], "mapped", [42651]], [[42651, 42651], "valid"], [[42652, 42652], "mapped", [1098]], [[42653, 42653], "mapped", [1100]], [[42654, 42654], "valid"], [[42655, 42655], "valid"], [[42656, 42725], "valid"], [[42726, 42735], "valid", [], "NV8"], [[42736, 42737], "valid"], [[42738, 42743], "valid", [], "NV8"], [[42744, 42751], "disallowed"], [[42752, 42774], "valid", [], "NV8"], [[42775, 42778], "valid"], [[42779, 42783], "valid"], [[42784, 42785], "valid", [], "NV8"], [[42786, 42786], "mapped", [42787]], [[42787, 42787], "valid"], [[42788, 42788], "mapped", [42789]], [[42789, 42789], "valid"], [[42790, 42790], "mapped", [42791]], [[42791, 42791], "valid"], [[42792, 42792], "mapped", [42793]], [[42793, 42793], "valid"], [[42794, 42794], "mapped", [42795]], [[42795, 42795], "valid"], [[42796, 42796], "mapped", [42797]], [[42797, 42797], "valid"], [[42798, 42798], "mapped", [42799]], [[42799, 42801], "valid"], [[42802, 42802], "mapped", [42803]], [[42803, 42803], "valid"], [[42804, 42804], "mapped", [42805]], [[42805, 42805], "valid"], [[42806, 42806], "mapped", [42807]], [[42807, 42807], "valid"], [[42808, 42808], "mapped", [42809]], [[42809, 42809], "valid"], [[42810, 42810], "mapped", [42811]], [[42811, 42811], "valid"], [[42812, 42812], "mapped", [42813]], [[42813, 42813], "valid"], [[42814, 42814], "mapped", [42815]], [[42815, 42815], "valid"], [[42816, 42816], "mapped", [42817]], [[42817, 42817], "valid"], [[42818, 42818], "mapped", [42819]], [[42819, 42819], "valid"], [[42820, 42820], "mapped", [42821]], [[42821, 42821], "valid"], [[42822, 42822], "mapped", [42823]], [[42823, 42823], "valid"], [[42824, 42824], "mapped", [42825]], [[42825, 42825], "valid"], [[42826, 42826], "mapped", [42827]], [[42827, 42827], "valid"], [[42828, 42828], "mapped", [42829]], [[42829, 42829], "valid"], [[42830, 42830], "mapped", [42831]], [[42831, 42831], "valid"], [[42832, 42832], "mapped", [42833]], [[42833, 42833], "valid"], [[42834, 42834], "mapped", [42835]], [[42835, 42835], "valid"], [[42836, 42836], "mapped", [42837]], [[42837, 42837], "valid"], [[42838, 42838], "mapped", [42839]], [[42839, 42839], "valid"], [[42840, 42840], "mapped", [42841]], [[42841, 42841], "valid"], [[42842, 42842], "mapped", [42843]], [[42843, 42843], "valid"], [[42844, 42844], "mapped", [42845]], [[42845, 42845], "valid"], [[42846, 42846], "mapped", [42847]], [[42847, 42847], "valid"], [[42848, 42848], "mapped", [42849]], [[42849, 42849], "valid"], [[42850, 42850], "mapped", [42851]], [[42851, 42851], "valid"], [[42852, 42852], "mapped", [42853]], [[42853, 42853], "valid"], [[42854, 42854], "mapped", [42855]], [[42855, 42855], "valid"], [[42856, 42856], "mapped", [42857]], [[42857, 42857], "valid"], [[42858, 42858], "mapped", [42859]], [[42859, 42859], "valid"], [[42860, 42860], "mapped", [42861]], [[42861, 42861], "valid"], [[42862, 42862], "mapped", [42863]], [[42863, 42863], "valid"], [[42864, 42864], "mapped", [42863]], [[42865, 42872], "valid"], [[42873, 42873], "mapped", [42874]], [[42874, 42874], "valid"], [[42875, 42875], "mapped", [42876]], [[42876, 42876], "valid"], [[42877, 42877], "mapped", [7545]], [[42878, 42878], "mapped", [42879]], [[42879, 42879], "valid"], [[42880, 42880], "mapped", [42881]], [[42881, 42881], "valid"], [[42882, 42882], "mapped", [42883]], [[42883, 42883], "valid"], [[42884, 42884], "mapped", [42885]], [[42885, 42885], "valid"], [[42886, 42886], "mapped", [42887]], [[42887, 42888], "valid"], [[42889, 42890], "valid", [], "NV8"], [[42891, 42891], "mapped", [42892]], [[42892, 42892], "valid"], [[42893, 42893], "mapped", [613]], [[42894, 42894], "valid"], [[42895, 42895], "valid"], [[42896, 42896], "mapped", [42897]], [[42897, 42897], "valid"], [[42898, 42898], "mapped", [42899]], [[42899, 42899], "valid"], [[42900, 42901], "valid"], [[42902, 42902], "mapped", [42903]], [[42903, 42903], "valid"], [[42904, 42904], "mapped", [42905]], [[42905, 42905], "valid"], [[42906, 42906], "mapped", [42907]], [[42907, 42907], "valid"], [[42908, 42908], "mapped", [42909]], [[42909, 42909], "valid"], [[42910, 42910], "mapped", [42911]], [[42911, 42911], "valid"], [[42912, 42912], "mapped", [42913]], [[42913, 42913], "valid"], [[42914, 42914], "mapped", [42915]], [[42915, 42915], "valid"], [[42916, 42916], "mapped", [42917]], [[42917, 42917], "valid"], [[42918, 42918], "mapped", [42919]], [[42919, 42919], "valid"], [[42920, 42920], "mapped", [42921]], [[42921, 42921], "valid"], [[42922, 42922], "mapped", [614]], [[42923, 42923], "mapped", [604]], [[42924, 42924], "mapped", [609]], [[42925, 42925], "mapped", [620]], [[42926, 42927], "disallowed"], [[42928, 42928], "mapped", [670]], [[42929, 42929], "mapped", [647]], [[42930, 42930], "mapped", [669]], [[42931, 42931], "mapped", [43859]], [[42932, 42932], "mapped", [42933]], [[42933, 42933], "valid"], [[42934, 42934], "mapped", [42935]], [[42935, 42935], "valid"], [[42936, 42998], "disallowed"], [[42999, 42999], "valid"], [[43000, 43000], "mapped", [295]], [[43001, 43001], "mapped", [339]], [[43002, 43002], "valid"], [[43003, 43007], "valid"], [[43008, 43047], "valid"], [[43048, 43051], "valid", [], "NV8"], [[43052, 43055], "disallowed"], [[43056, 43065], "valid", [], "NV8"], [[43066, 43071], "disallowed"], [[43072, 43123], "valid"], [[43124, 43127], "valid", [], "NV8"], [[43128, 43135], "disallowed"], [[43136, 43204], "valid"], [[43205, 43213], "disallowed"], [[43214, 43215], "valid", [], "NV8"], [[43216, 43225], "valid"], [[43226, 43231], "disallowed"], [[43232, 43255], "valid"], [[43256, 43258], "valid", [], "NV8"], [[43259, 43259], "valid"], [[43260, 43260], "valid", [], "NV8"], [[43261, 43261], "valid"], [[43262, 43263], "disallowed"], [[43264, 43309], "valid"], [[43310, 43311], "valid", [], "NV8"], [[43312, 43347], "valid"], [[43348, 43358], "disallowed"], [[43359, 43359], "valid", [], "NV8"], [[43360, 43388], "valid", [], "NV8"], [[43389, 43391], "disallowed"], [[43392, 43456], "valid"], [[43457, 43469], "valid", [], "NV8"], [[43470, 43470], "disallowed"], [[43471, 43481], "valid"], [[43482, 43485], "disallowed"], [[43486, 43487], "valid", [], "NV8"], [[43488, 43518], "valid"], [[43519, 43519], "disallowed"], [[43520, 43574], "valid"], [[43575, 43583], "disallowed"], [[43584, 43597], "valid"], [[43598, 43599], "disallowed"], [[43600, 43609], "valid"], [[43610, 43611], "disallowed"], [[43612, 43615], "valid", [], "NV8"], [[43616, 43638], "valid"], [[43639, 43641], "valid", [], "NV8"], [[43642, 43643], "valid"], [[43644, 43647], "valid"], [[43648, 43714], "valid"], [[43715, 43738], "disallowed"], [[43739, 43741], "valid"], [[43742, 43743], "valid", [], "NV8"], [[43744, 43759], "valid"], [[43760, 43761], "valid", [], "NV8"], [[43762, 43766], "valid"], [[43767, 43776], "disallowed"], [[43777, 43782], "valid"], [[43783, 43784], "disallowed"], [[43785, 43790], "valid"], [[43791, 43792], "disallowed"], [[43793, 43798], "valid"], [[43799, 43807], "disallowed"], [[43808, 43814], "valid"], [[43815, 43815], "disallowed"], [[43816, 43822], "valid"], [[43823, 43823], "disallowed"], [[43824, 43866], "valid"], [[43867, 43867], "valid", [], "NV8"], [[43868, 43868], "mapped", [42791]], [[43869, 43869], "mapped", [43831]], [[43870, 43870], "mapped", [619]], [[43871, 43871], "mapped", [43858]], [[43872, 43875], "valid"], [[43876, 43877], "valid"], [[43878, 43887], "disallowed"], [[43888, 43888], "mapped", [5024]], [[43889, 43889], "mapped", [5025]], [[43890, 43890], "mapped", [5026]], [[43891, 43891], "mapped", [5027]], [[43892, 43892], "mapped", [5028]], [[43893, 43893], "mapped", [5029]], [[43894, 43894], "mapped", [5030]], [[43895, 43895], "mapped", [5031]], [[43896, 43896], "mapped", [5032]], [[43897, 43897], "mapped", [5033]], [[43898, 43898], "mapped", [5034]], [[43899, 43899], "mapped", [5035]], [[43900, 43900], "mapped", [5036]], [[43901, 43901], "mapped", [5037]], [[43902, 43902], "mapped", [5038]], [[43903, 43903], "mapped", [5039]], [[43904, 43904], "mapped", [5040]], [[43905, 43905], "mapped", [5041]], [[43906, 43906], "mapped", [5042]], [[43907, 43907], "mapped", [5043]], [[43908, 43908], "mapped", [5044]], [[43909, 43909], "mapped", [5045]], [[43910, 43910], "mapped", [5046]], [[43911, 43911], "mapped", [5047]], [[43912, 43912], "mapped", [5048]], [[43913, 43913], "mapped", [5049]], [[43914, 43914], "mapped", [5050]], [[43915, 43915], "mapped", [5051]], [[43916, 43916], "mapped", [5052]], [[43917, 43917], "mapped", [5053]], [[43918, 43918], "mapped", [5054]], [[43919, 43919], "mapped", [5055]], [[43920, 43920], "mapped", [5056]], [[43921, 43921], "mapped", [5057]], [[43922, 43922], "mapped", [5058]], [[43923, 43923], "mapped", [5059]], [[43924, 43924], "mapped", [5060]], [[43925, 43925], "mapped", [5061]], [[43926, 43926], "mapped", [5062]], [[43927, 43927], "mapped", [5063]], [[43928, 43928], "mapped", [5064]], [[43929, 43929], "mapped", [5065]], [[43930, 43930], "mapped", [5066]], [[43931, 43931], "mapped", [5067]], [[43932, 43932], "mapped", [5068]], [[43933, 43933], "mapped", [5069]], [[43934, 43934], "mapped", [5070]], [[43935, 43935], "mapped", [5071]], [[43936, 43936], "mapped", [5072]], [[43937, 43937], "mapped", [5073]], [[43938, 43938], "mapped", [5074]], [[43939, 43939], "mapped", [5075]], [[43940, 43940], "mapped", [5076]], [[43941, 43941], "mapped", [5077]], [[43942, 43942], "mapped", [5078]], [[43943, 43943], "mapped", [5079]], [[43944, 43944], "mapped", [5080]], [[43945, 43945], "mapped", [5081]], [[43946, 43946], "mapped", [5082]], [[43947, 43947], "mapped", [5083]], [[43948, 43948], "mapped", [5084]], [[43949, 43949], "mapped", [5085]], [[43950, 43950], "mapped", [5086]], [[43951, 43951], "mapped", [5087]], [[43952, 43952], "mapped", [5088]], [[43953, 43953], "mapped", [5089]], [[43954, 43954], "mapped", [5090]], [[43955, 43955], "mapped", [5091]], [[43956, 43956], "mapped", [5092]], [[43957, 43957], "mapped", [5093]], [[43958, 43958], "mapped", [5094]], [[43959, 43959], "mapped", [5095]], [[43960, 43960], "mapped", [5096]], [[43961, 43961], "mapped", [5097]], [[43962, 43962], "mapped", [5098]], [[43963, 43963], "mapped", [5099]], [[43964, 43964], "mapped", [5100]], [[43965, 43965], "mapped", [5101]], [[43966, 43966], "mapped", [5102]], [[43967, 43967], "mapped", [5103]], [[43968, 44010], "valid"], [[44011, 44011], "valid", [], "NV8"], [[44012, 44013], "valid"], [[44014, 44015], "disallowed"], [[44016, 44025], "valid"], [[44026, 44031], "disallowed"], [[44032, 55203], "valid"], [[55204, 55215], "disallowed"], [[55216, 55238], "valid", [], "NV8"], [[55239, 55242], "disallowed"], [[55243, 55291], "valid", [], "NV8"], [[55292, 55295], "disallowed"], [[55296, 57343], "disallowed"], [[57344, 63743], "disallowed"], [[63744, 63744], "mapped", [35912]], [[63745, 63745], "mapped", [26356]], [[63746, 63746], "mapped", [36554]], [[63747, 63747], "mapped", [36040]], [[63748, 63748], "mapped", [28369]], [[63749, 63749], "mapped", [20018]], [[63750, 63750], "mapped", [21477]], [[63751, 63752], "mapped", [40860]], [[63753, 63753], "mapped", [22865]], [[63754, 63754], "mapped", [37329]], [[63755, 63755], "mapped", [21895]], [[63756, 63756], "mapped", [22856]], [[63757, 63757], "mapped", [25078]], [[63758, 63758], "mapped", [30313]], [[63759, 63759], "mapped", [32645]], [[63760, 63760], "mapped", [34367]], [[63761, 63761], "mapped", [34746]], [[63762, 63762], "mapped", [35064]], [[63763, 63763], "mapped", [37007]], [[63764, 63764], "mapped", [27138]], [[63765, 63765], "mapped", [27931]], [[63766, 63766], "mapped", [28889]], [[63767, 63767], "mapped", [29662]], [[63768, 63768], "mapped", [33853]], [[63769, 63769], "mapped", [37226]], [[63770, 63770], "mapped", [39409]], [[63771, 63771], "mapped", [20098]], [[63772, 63772], "mapped", [21365]], [[63773, 63773], "mapped", [27396]], [[63774, 63774], "mapped", [29211]], [[63775, 63775], "mapped", [34349]], [[63776, 63776], "mapped", [40478]], [[63777, 63777], "mapped", [23888]], [[63778, 63778], "mapped", [28651]], [[63779, 63779], "mapped", [34253]], [[63780, 63780], "mapped", [35172]], [[63781, 63781], "mapped", [25289]], [[63782, 63782], "mapped", [33240]], [[63783, 63783], "mapped", [34847]], [[63784, 63784], "mapped", [24266]], [[63785, 63785], "mapped", [26391]], [[63786, 63786], "mapped", [28010]], [[63787, 63787], "mapped", [29436]], [[63788, 63788], "mapped", [37070]], [[63789, 63789], "mapped", [20358]], [[63790, 63790], "mapped", [20919]], [[63791, 63791], "mapped", [21214]], [[63792, 63792], "mapped", [25796]], [[63793, 63793], "mapped", [27347]], [[63794, 63794], "mapped", [29200]], [[63795, 63795], "mapped", [30439]], [[63796, 63796], "mapped", [32769]], [[63797, 63797], "mapped", [34310]], [[63798, 63798], "mapped", [34396]], [[63799, 63799], "mapped", [36335]], [[63800, 63800], "mapped", [38706]], [[63801, 63801], "mapped", [39791]], [[63802, 63802], "mapped", [40442]], [[63803, 63803], "mapped", [30860]], [[63804, 63804], "mapped", [31103]], [[63805, 63805], "mapped", [32160]], [[63806, 63806], "mapped", [33737]], [[63807, 63807], "mapped", [37636]], [[63808, 63808], "mapped", [40575]], [[63809, 63809], "mapped", [35542]], [[63810, 63810], "mapped", [22751]], [[63811, 63811], "mapped", [24324]], [[63812, 63812], "mapped", [31840]], [[63813, 63813], "mapped", [32894]], [[63814, 63814], "mapped", [29282]], [[63815, 63815], "mapped", [30922]], [[63816, 63816], "mapped", [36034]], [[63817, 63817], "mapped", [38647]], [[63818, 63818], "mapped", [22744]], [[63819, 63819], "mapped", [23650]], [[63820, 63820], "mapped", [27155]], [[63821, 63821], "mapped", [28122]], [[63822, 63822], "mapped", [28431]], [[63823, 63823], "mapped", [32047]], [[63824, 63824], "mapped", [32311]], [[63825, 63825], "mapped", [38475]], [[63826, 63826], "mapped", [21202]], [[63827, 63827], "mapped", [32907]], [[63828, 63828], "mapped", [20956]], [[63829, 63829], "mapped", [20940]], [[63830, 63830], "mapped", [31260]], [[63831, 63831], "mapped", [32190]], [[63832, 63832], "mapped", [33777]], [[63833, 63833], "mapped", [38517]], [[63834, 63834], "mapped", [35712]], [[63835, 63835], "mapped", [25295]], [[63836, 63836], "mapped", [27138]], [[63837, 63837], "mapped", [35582]], [[63838, 63838], "mapped", [20025]], [[63839, 63839], "mapped", [23527]], [[63840, 63840], "mapped", [24594]], [[63841, 63841], "mapped", [29575]], [[63842, 63842], "mapped", [30064]], [[63843, 63843], "mapped", [21271]], [[63844, 63844], "mapped", [30971]], [[63845, 63845], "mapped", [20415]], [[63846, 63846], "mapped", [24489]], [[63847, 63847], "mapped", [19981]], [[63848, 63848], "mapped", [27852]], [[63849, 63849], "mapped", [25976]], [[63850, 63850], "mapped", [32034]], [[63851, 63851], "mapped", [21443]], [[63852, 63852], "mapped", [22622]], [[63853, 63853], "mapped", [30465]], [[63854, 63854], "mapped", [33865]], [[63855, 63855], "mapped", [35498]], [[63856, 63856], "mapped", [27578]], [[63857, 63857], "mapped", [36784]], [[63858, 63858], "mapped", [27784]], [[63859, 63859], "mapped", [25342]], [[63860, 63860], "mapped", [33509]], [[63861, 63861], "mapped", [25504]], [[63862, 63862], "mapped", [30053]], [[63863, 63863], "mapped", [20142]], [[63864, 63864], "mapped", [20841]], [[63865, 63865], "mapped", [20937]], [[63866, 63866], "mapped", [26753]], [[63867, 63867], "mapped", [31975]], [[63868, 63868], "mapped", [33391]], [[63869, 63869], "mapped", [35538]], [[63870, 63870], "mapped", [37327]], [[63871, 63871], "mapped", [21237]], [[63872, 63872], "mapped", [21570]], [[63873, 63873], "mapped", [22899]], [[63874, 63874], "mapped", [24300]], [[63875, 63875], "mapped", [26053]], [[63876, 63876], "mapped", [28670]], [[63877, 63877], "mapped", [31018]], [[63878, 63878], "mapped", [38317]], [[63879, 63879], "mapped", [39530]], [[63880, 63880], "mapped", [40599]], [[63881, 63881], "mapped", [40654]], [[63882, 63882], "mapped", [21147]], [[63883, 63883], "mapped", [26310]], [[63884, 63884], "mapped", [27511]], [[63885, 63885], "mapped", [36706]], [[63886, 63886], "mapped", [24180]], [[63887, 63887], "mapped", [24976]], [[63888, 63888], "mapped", [25088]], [[63889, 63889], "mapped", [25754]], [[63890, 63890], "mapped", [28451]], [[63891, 63891], "mapped", [29001]], [[63892, 63892], "mapped", [29833]], [[63893, 63893], "mapped", [31178]], [[63894, 63894], "mapped", [32244]], [[63895, 63895], "mapped", [32879]], [[63896, 63896], "mapped", [36646]], [[63897, 63897], "mapped", [34030]], [[63898, 63898], "mapped", [36899]], [[63899, 63899], "mapped", [37706]], [[63900, 63900], "mapped", [21015]], [[63901, 63901], "mapped", [21155]], [[63902, 63902], "mapped", [21693]], [[63903, 63903], "mapped", [28872]], [[63904, 63904], "mapped", [35010]], [[63905, 63905], "mapped", [35498]], [[63906, 63906], "mapped", [24265]], [[63907, 63907], "mapped", [24565]], [[63908, 63908], "mapped", [25467]], [[63909, 63909], "mapped", [27566]], [[63910, 63910], "mapped", [31806]], [[63911, 63911], "mapped", [29557]], [[63912, 63912], "mapped", [20196]], [[63913, 63913], "mapped", [22265]], [[63914, 63914], "mapped", [23527]], [[63915, 63915], "mapped", [23994]], [[63916, 63916], "mapped", [24604]], [[63917, 63917], "mapped", [29618]], [[63918, 63918], "mapped", [29801]], [[63919, 63919], "mapped", [32666]], [[63920, 63920], "mapped", [32838]], [[63921, 63921], "mapped", [37428]], [[63922, 63922], "mapped", [38646]], [[63923, 63923], "mapped", [38728]], [[63924, 63924], "mapped", [38936]], [[63925, 63925], "mapped", [20363]], [[63926, 63926], "mapped", [31150]], [[63927, 63927], "mapped", [37300]], [[63928, 63928], "mapped", [38584]], [[63929, 63929], "mapped", [24801]], [[63930, 63930], "mapped", [20102]], [[63931, 63931], "mapped", [20698]], [[63932, 63932], "mapped", [23534]], [[63933, 63933], "mapped", [23615]], [[63934, 63934], "mapped", [26009]], [[63935, 63935], "mapped", [27138]], [[63936, 63936], "mapped", [29134]], [[63937, 63937], "mapped", [30274]], [[63938, 63938], "mapped", [34044]], [[63939, 63939], "mapped", [36988]], [[63940, 63940], "mapped", [40845]], [[63941, 63941], "mapped", [26248]], [[63942, 63942], "mapped", [38446]], [[63943, 63943], "mapped", [21129]], [[63944, 63944], "mapped", [26491]], [[63945, 63945], "mapped", [26611]], [[63946, 63946], "mapped", [27969]], [[63947, 63947], "mapped", [28316]], [[63948, 63948], "mapped", [29705]], [[63949, 63949], "mapped", [30041]], [[63950, 63950], "mapped", [30827]], [[63951, 63951], "mapped", [32016]], [[63952, 63952], "mapped", [39006]], [[63953, 63953], "mapped", [20845]], [[63954, 63954], "mapped", [25134]], [[63955, 63955], "mapped", [38520]], [[63956, 63956], "mapped", [20523]], [[63957, 63957], "mapped", [23833]], [[63958, 63958], "mapped", [28138]], [[63959, 63959], "mapped", [36650]], [[63960, 63960], "mapped", [24459]], [[63961, 63961], "mapped", [24900]], [[63962, 63962], "mapped", [26647]], [[63963, 63963], "mapped", [29575]], [[63964, 63964], "mapped", [38534]], [[63965, 63965], "mapped", [21033]], [[63966, 63966], "mapped", [21519]], [[63967, 63967], "mapped", [23653]], [[63968, 63968], "mapped", [26131]], [[63969, 63969], "mapped", [26446]], [[63970, 63970], "mapped", [26792]], [[63971, 63971], "mapped", [27877]], [[63972, 63972], "mapped", [29702]], [[63973, 63973], "mapped", [30178]], [[63974, 63974], "mapped", [32633]], [[63975, 63975], "mapped", [35023]], [[63976, 63976], "mapped", [35041]], [[63977, 63977], "mapped", [37324]], [[63978, 63978], "mapped", [38626]], [[63979, 63979], "mapped", [21311]], [[63980, 63980], "mapped", [28346]], [[63981, 63981], "mapped", [21533]], [[63982, 63982], "mapped", [29136]], [[63983, 63983], "mapped", [29848]], [[63984, 63984], "mapped", [34298]], [[63985, 63985], "mapped", [38563]], [[63986, 63986], "mapped", [40023]], [[63987, 63987], "mapped", [40607]], [[63988, 63988], "mapped", [26519]], [[63989, 63989], "mapped", [28107]], [[63990, 63990], "mapped", [33256]], [[63991, 63991], "mapped", [31435]], [[63992, 63992], "mapped", [31520]], [[63993, 63993], "mapped", [31890]], [[63994, 63994], "mapped", [29376]], [[63995, 63995], "mapped", [28825]], [[63996, 63996], "mapped", [35672]], [[63997, 63997], "mapped", [20160]], [[63998, 63998], "mapped", [33590]], [[63999, 63999], "mapped", [21050]], [[64000, 64000], "mapped", [20999]], [[64001, 64001], "mapped", [24230]], [[64002, 64002], "mapped", [25299]], [[64003, 64003], "mapped", [31958]], [[64004, 64004], "mapped", [23429]], [[64005, 64005], "mapped", [27934]], [[64006, 64006], "mapped", [26292]], [[64007, 64007], "mapped", [36667]], [[64008, 64008], "mapped", [34892]], [[64009, 64009], "mapped", [38477]], [[64010, 64010], "mapped", [35211]], [[64011, 64011], "mapped", [24275]], [[64012, 64012], "mapped", [20800]], [[64013, 64013], "mapped", [21952]], [[64014, 64015], "valid"], [[64016, 64016], "mapped", [22618]], [[64017, 64017], "valid"], [[64018, 64018], "mapped", [26228]], [[64019, 64020], "valid"], [[64021, 64021], "mapped", [20958]], [[64022, 64022], "mapped", [29482]], [[64023, 64023], "mapped", [30410]], [[64024, 64024], "mapped", [31036]], [[64025, 64025], "mapped", [31070]], [[64026, 64026], "mapped", [31077]], [[64027, 64027], "mapped", [31119]], [[64028, 64028], "mapped", [38742]], [[64029, 64029], "mapped", [31934]], [[64030, 64030], "mapped", [32701]], [[64031, 64031], "valid"], [[64032, 64032], "mapped", [34322]], [[64033, 64033], "valid"], [[64034, 64034], "mapped", [35576]], [[64035, 64036], "valid"], [[64037, 64037], "mapped", [36920]], [[64038, 64038], "mapped", [37117]], [[64039, 64041], "valid"], [[64042, 64042], "mapped", [39151]], [[64043, 64043], "mapped", [39164]], [[64044, 64044], "mapped", [39208]], [[64045, 64045], "mapped", [40372]], [[64046, 64046], "mapped", [37086]], [[64047, 64047], "mapped", [38583]], [[64048, 64048], "mapped", [20398]], [[64049, 64049], "mapped", [20711]], [[64050, 64050], "mapped", [20813]], [[64051, 64051], "mapped", [21193]], [[64052, 64052], "mapped", [21220]], [[64053, 64053], "mapped", [21329]], [[64054, 64054], "mapped", [21917]], [[64055, 64055], "mapped", [22022]], [[64056, 64056], "mapped", [22120]], [[64057, 64057], "mapped", [22592]], [[64058, 64058], "mapped", [22696]], [[64059, 64059], "mapped", [23652]], [[64060, 64060], "mapped", [23662]], [[64061, 64061], "mapped", [24724]], [[64062, 64062], "mapped", [24936]], [[64063, 64063], "mapped", [24974]], [[64064, 64064], "mapped", [25074]], [[64065, 64065], "mapped", [25935]], [[64066, 64066], "mapped", [26082]], [[64067, 64067], "mapped", [26257]], [[64068, 64068], "mapped", [26757]], [[64069, 64069], "mapped", [28023]], [[64070, 64070], "mapped", [28186]], [[64071, 64071], "mapped", [28450]], [[64072, 64072], "mapped", [29038]], [[64073, 64073], "mapped", [29227]], [[64074, 64074], "mapped", [29730]], [[64075, 64075], "mapped", [30865]], [[64076, 64076], "mapped", [31038]], [[64077, 64077], "mapped", [31049]], [[64078, 64078], "mapped", [31048]], [[64079, 64079], "mapped", [31056]], [[64080, 64080], "mapped", [31062]], [[64081, 64081], "mapped", [31069]], [[64082, 64082], "mapped", [31117]], [[64083, 64083], "mapped", [31118]], [[64084, 64084], "mapped", [31296]], [[64085, 64085], "mapped", [31361]], [[64086, 64086], "mapped", [31680]], [[64087, 64087], "mapped", [32244]], [[64088, 64088], "mapped", [32265]], [[64089, 64089], "mapped", [32321]], [[64090, 64090], "mapped", [32626]], [[64091, 64091], "mapped", [32773]], [[64092, 64092], "mapped", [33261]], [[64093, 64094], "mapped", [33401]], [[64095, 64095], "mapped", [33879]], [[64096, 64096], "mapped", [35088]], [[64097, 64097], "mapped", [35222]], [[64098, 64098], "mapped", [35585]], [[64099, 64099], "mapped", [35641]], [[64100, 64100], "mapped", [36051]], [[64101, 64101], "mapped", [36104]], [[64102, 64102], "mapped", [36790]], [[64103, 64103], "mapped", [36920]], [[64104, 64104], "mapped", [38627]], [[64105, 64105], "mapped", [38911]], [[64106, 64106], "mapped", [38971]], [[64107, 64107], "mapped", [24693]], [[64108, 64108], "mapped", [148206]], [[64109, 64109], "mapped", [33304]], [[64110, 64111], "disallowed"], [[64112, 64112], "mapped", [20006]], [[64113, 64113], "mapped", [20917]], [[64114, 64114], "mapped", [20840]], [[64115, 64115], "mapped", [20352]], [[64116, 64116], "mapped", [20805]], [[64117, 64117], "mapped", [20864]], [[64118, 64118], "mapped", [21191]], [[64119, 64119], "mapped", [21242]], [[64120, 64120], "mapped", [21917]], [[64121, 64121], "mapped", [21845]], [[64122, 64122], "mapped", [21913]], [[64123, 64123], "mapped", [21986]], [[64124, 64124], "mapped", [22618]], [[64125, 64125], "mapped", [22707]], [[64126, 64126], "mapped", [22852]], [[64127, 64127], "mapped", [22868]], [[64128, 64128], "mapped", [23138]], [[64129, 64129], "mapped", [23336]], [[64130, 64130], "mapped", [24274]], [[64131, 64131], "mapped", [24281]], [[64132, 64132], "mapped", [24425]], [[64133, 64133], "mapped", [24493]], [[64134, 64134], "mapped", [24792]], [[64135, 64135], "mapped", [24910]], [[64136, 64136], "mapped", [24840]], [[64137, 64137], "mapped", [24974]], [[64138, 64138], "mapped", [24928]], [[64139, 64139], "mapped", [25074]], [[64140, 64140], "mapped", [25140]], [[64141, 64141], "mapped", [25540]], [[64142, 64142], "mapped", [25628]], [[64143, 64143], "mapped", [25682]], [[64144, 64144], "mapped", [25942]], [[64145, 64145], "mapped", [26228]], [[64146, 64146], "mapped", [26391]], [[64147, 64147], "mapped", [26395]], [[64148, 64148], "mapped", [26454]], [[64149, 64149], "mapped", [27513]], [[64150, 64150], "mapped", [27578]], [[64151, 64151], "mapped", [27969]], [[64152, 64152], "mapped", [28379]], [[64153, 64153], "mapped", [28363]], [[64154, 64154], "mapped", [28450]], [[64155, 64155], "mapped", [28702]], [[64156, 64156], "mapped", [29038]], [[64157, 64157], "mapped", [30631]], [[64158, 64158], "mapped", [29237]], [[64159, 64159], "mapped", [29359]], [[64160, 64160], "mapped", [29482]], [[64161, 64161], "mapped", [29809]], [[64162, 64162], "mapped", [29958]], [[64163, 64163], "mapped", [30011]], [[64164, 64164], "mapped", [30237]], [[64165, 64165], "mapped", [30239]], [[64166, 64166], "mapped", [30410]], [[64167, 64167], "mapped", [30427]], [[64168, 64168], "mapped", [30452]], [[64169, 64169], "mapped", [30538]], [[64170, 64170], "mapped", [30528]], [[64171, 64171], "mapped", [30924]], [[64172, 64172], "mapped", [31409]], [[64173, 64173], "mapped", [31680]], [[64174, 64174], "mapped", [31867]], [[64175, 64175], "mapped", [32091]], [[64176, 64176], "mapped", [32244]], [[64177, 64177], "mapped", [32574]], [[64178, 64178], "mapped", [32773]], [[64179, 64179], "mapped", [33618]], [[64180, 64180], "mapped", [33775]], [[64181, 64181], "mapped", [34681]], [[64182, 64182], "mapped", [35137]], [[64183, 64183], "mapped", [35206]], [[64184, 64184], "mapped", [35222]], [[64185, 64185], "mapped", [35519]], [[64186, 64186], "mapped", [35576]], [[64187, 64187], "mapped", [35531]], [[64188, 64188], "mapped", [35585]], [[64189, 64189], "mapped", [35582]], [[64190, 64190], "mapped", [35565]], [[64191, 64191], "mapped", [35641]], [[64192, 64192], "mapped", [35722]], [[64193, 64193], "mapped", [36104]], [[64194, 64194], "mapped", [36664]], [[64195, 64195], "mapped", [36978]], [[64196, 64196], "mapped", [37273]], [[64197, 64197], "mapped", [37494]], [[64198, 64198], "mapped", [38524]], [[64199, 64199], "mapped", [38627]], [[64200, 64200], "mapped", [38742]], [[64201, 64201], "mapped", [38875]], [[64202, 64202], "mapped", [38911]], [[64203, 64203], "mapped", [38923]], [[64204, 64204], "mapped", [38971]], [[64205, 64205], "mapped", [39698]], [[64206, 64206], "mapped", [40860]], [[64207, 64207], "mapped", [141386]], [[64208, 64208], "mapped", [141380]], [[64209, 64209], "mapped", [144341]], [[64210, 64210], "mapped", [15261]], [[64211, 64211], "mapped", [16408]], [[64212, 64212], "mapped", [16441]], [[64213, 64213], "mapped", [152137]], [[64214, 64214], "mapped", [154832]], [[64215, 64215], "mapped", [163539]], [[64216, 64216], "mapped", [40771]], [[64217, 64217], "mapped", [40846]], [[64218, 64255], "disallowed"], [[64256, 64256], "mapped", [102, 102]], [[64257, 64257], "mapped", [102, 105]], [[64258, 64258], "mapped", [102, 108]], [[64259, 64259], "mapped", [102, 102, 105]], [[64260, 64260], "mapped", [102, 102, 108]], [[64261, 64262], "mapped", [115, 116]], [[64263, 64274], "disallowed"], [[64275, 64275], "mapped", [1396, 1398]], [[64276, 64276], "mapped", [1396, 1381]], [[64277, 64277], "mapped", [1396, 1387]], [[64278, 64278], "mapped", [1406, 1398]], [[64279, 64279], "mapped", [1396, 1389]], [[64280, 64284], "disallowed"], [[64285, 64285], "mapped", [1497, 1460]], [[64286, 64286], "valid"], [[64287, 64287], "mapped", [1522, 1463]], [[64288, 64288], "mapped", [1506]], [[64289, 64289], "mapped", [1488]], [[64290, 64290], "mapped", [1491]], [[64291, 64291], "mapped", [1492]], [[64292, 64292], "mapped", [1499]], [[64293, 64293], "mapped", [1500]], [[64294, 64294], "mapped", [1501]], [[64295, 64295], "mapped", [1512]], [[64296, 64296], "mapped", [1514]], [[64297, 64297], "disallowed_STD3_mapped", [43]], [[64298, 64298], "mapped", [1513, 1473]], [[64299, 64299], "mapped", [1513, 1474]], [[64300, 64300], "mapped", [1513, 1468, 1473]], [[64301, 64301], "mapped", [1513, 1468, 1474]], [[64302, 64302], "mapped", [1488, 1463]], [[64303, 64303], "mapped", [1488, 1464]], [[64304, 64304], "mapped", [1488, 1468]], [[64305, 64305], "mapped", [1489, 1468]], [[64306, 64306], "mapped", [1490, 1468]], [[64307, 64307], "mapped", [1491, 1468]], [[64308, 64308], "mapped", [1492, 1468]], [[64309, 64309], "mapped", [1493, 1468]], [[64310, 64310], "mapped", [1494, 1468]], [[64311, 64311], "disallowed"], [[64312, 64312], "mapped", [1496, 1468]], [[64313, 64313], "mapped", [1497, 1468]], [[64314, 64314], "mapped", [1498, 1468]], [[64315, 64315], "mapped", [1499, 1468]], [[64316, 64316], "mapped", [1500, 1468]], [[64317, 64317], "disallowed"], [[64318, 64318], "mapped", [1502, 1468]], [[64319, 64319], "disallowed"], [[64320, 64320], "mapped", [1504, 1468]], [[64321, 64321], "mapped", [1505, 1468]], [[64322, 64322], "disallowed"], [[64323, 64323], "mapped", [1507, 1468]], [[64324, 64324], "mapped", [1508, 1468]], [[64325, 64325], "disallowed"], [[64326, 64326], "mapped", [1510, 1468]], [[64327, 64327], "mapped", [1511, 1468]], [[64328, 64328], "mapped", [1512, 1468]], [[64329, 64329], "mapped", [1513, 1468]], [[64330, 64330], "mapped", [1514, 1468]], [[64331, 64331], "mapped", [1493, 1465]], [[64332, 64332], "mapped", [1489, 1471]], [[64333, 64333], "mapped", [1499, 1471]], [[64334, 64334], "mapped", [1508, 1471]], [[64335, 64335], "mapped", [1488, 1500]], [[64336, 64337], "mapped", [1649]], [[64338, 64341], "mapped", [1659]], [[64342, 64345], "mapped", [1662]], [[64346, 64349], "mapped", [1664]], [[64350, 64353], "mapped", [1658]], [[64354, 64357], "mapped", [1663]], [[64358, 64361], "mapped", [1657]], [[64362, 64365], "mapped", [1700]], [[64366, 64369], "mapped", [1702]], [[64370, 64373], "mapped", [1668]], [[64374, 64377], "mapped", [1667]], [[64378, 64381], "mapped", [1670]], [[64382, 64385], "mapped", [1671]], [[64386, 64387], "mapped", [1677]], [[64388, 64389], "mapped", [1676]], [[64390, 64391], "mapped", [1678]], [[64392, 64393], "mapped", [1672]], [[64394, 64395], "mapped", [1688]], [[64396, 64397], "mapped", [1681]], [[64398, 64401], "mapped", [1705]], [[64402, 64405], "mapped", [1711]], [[64406, 64409], "mapped", [1715]], [[64410, 64413], "mapped", [1713]], [[64414, 64415], "mapped", [1722]], [[64416, 64419], "mapped", [1723]], [[64420, 64421], "mapped", [1728]], [[64422, 64425], "mapped", [1729]], [[64426, 64429], "mapped", [1726]], [[64430, 64431], "mapped", [1746]], [[64432, 64433], "mapped", [1747]], [[64434, 64449], "valid", [], "NV8"], [[64450, 64466], "disallowed"], [[64467, 64470], "mapped", [1709]], [[64471, 64472], "mapped", [1735]], [[64473, 64474], "mapped", [1734]], [[64475, 64476], "mapped", [1736]], [[64477, 64477], "mapped", [1735, 1652]], [[64478, 64479], "mapped", [1739]], [[64480, 64481], "mapped", [1733]], [[64482, 64483], "mapped", [1737]], [[64484, 64487], "mapped", [1744]], [[64488, 64489], "mapped", [1609]], [[64490, 64491], "mapped", [1574, 1575]], [[64492, 64493], "mapped", [1574, 1749]], [[64494, 64495], "mapped", [1574, 1608]], [[64496, 64497], "mapped", [1574, 1735]], [[64498, 64499], "mapped", [1574, 1734]], [[64500, 64501], "mapped", [1574, 1736]], [[64502, 64504], "mapped", [1574, 1744]], [[64505, 64507], "mapped", [1574, 1609]], [[64508, 64511], "mapped", [1740]], [[64512, 64512], "mapped", [1574, 1580]], [[64513, 64513], "mapped", [1574, 1581]], [[64514, 64514], "mapped", [1574, 1605]], [[64515, 64515], "mapped", [1574, 1609]], [[64516, 64516], "mapped", [1574, 1610]], [[64517, 64517], "mapped", [1576, 1580]], [[64518, 64518], "mapped", [1576, 1581]], [[64519, 64519], "mapped", [1576, 1582]], [[64520, 64520], "mapped", [1576, 1605]], [[64521, 64521], "mapped", [1576, 1609]], [[64522, 64522], "mapped", [1576, 1610]], [[64523, 64523], "mapped", [1578, 1580]], [[64524, 64524], "mapped", [1578, 1581]], [[64525, 64525], "mapped", [1578, 1582]], [[64526, 64526], "mapped", [1578, 1605]], [[64527, 64527], "mapped", [1578, 1609]], [[64528, 64528], "mapped", [1578, 1610]], [[64529, 64529], "mapped", [1579, 1580]], [[64530, 64530], "mapped", [1579, 1605]], [[64531, 64531], "mapped", [1579, 1609]], [[64532, 64532], "mapped", [1579, 1610]], [[64533, 64533], "mapped", [1580, 1581]], [[64534, 64534], "mapped", [1580, 1605]], [[64535, 64535], "mapped", [1581, 1580]], [[64536, 64536], "mapped", [1581, 1605]], [[64537, 64537], "mapped", [1582, 1580]], [[64538, 64538], "mapped", [1582, 1581]], [[64539, 64539], "mapped", [1582, 1605]], [[64540, 64540], "mapped", [1587, 1580]], [[64541, 64541], "mapped", [1587, 1581]], [[64542, 64542], "mapped", [1587, 1582]], [[64543, 64543], "mapped", [1587, 1605]], [[64544, 64544], "mapped", [1589, 1581]], [[64545, 64545], "mapped", [1589, 1605]], [[64546, 64546], "mapped", [1590, 1580]], [[64547, 64547], "mapped", [1590, 1581]], [[64548, 64548], "mapped", [1590, 1582]], [[64549, 64549], "mapped", [1590, 1605]], [[64550, 64550], "mapped", [1591, 1581]], [[64551, 64551], "mapped", [1591, 1605]], [[64552, 64552], "mapped", [1592, 1605]], [[64553, 64553], "mapped", [1593, 1580]], [[64554, 64554], "mapped", [1593, 1605]], [[64555, 64555], "mapped", [1594, 1580]], [[64556, 64556], "mapped", [1594, 1605]], [[64557, 64557], "mapped", [1601, 1580]], [[64558, 64558], "mapped", [1601, 1581]], [[64559, 64559], "mapped", [1601, 1582]], [[64560, 64560], "mapped", [1601, 1605]], [[64561, 64561], "mapped", [1601, 1609]], [[64562, 64562], "mapped", [1601, 1610]], [[64563, 64563], "mapped", [1602, 1581]], [[64564, 64564], "mapped", [1602, 1605]], [[64565, 64565], "mapped", [1602, 1609]], [[64566, 64566], "mapped", [1602, 1610]], [[64567, 64567], "mapped", [1603, 1575]], [[64568, 64568], "mapped", [1603, 1580]], [[64569, 64569], "mapped", [1603, 1581]], [[64570, 64570], "mapped", [1603, 1582]], [[64571, 64571], "mapped", [1603, 1604]], [[64572, 64572], "mapped", [1603, 1605]], [[64573, 64573], "mapped", [1603, 1609]], [[64574, 64574], "mapped", [1603, 1610]], [[64575, 64575], "mapped", [1604, 1580]], [[64576, 64576], "mapped", [1604, 1581]], [[64577, 64577], "mapped", [1604, 1582]], [[64578, 64578], "mapped", [1604, 1605]], [[64579, 64579], "mapped", [1604, 1609]], [[64580, 64580], "mapped", [1604, 1610]], [[64581, 64581], "mapped", [1605, 1580]], [[64582, 64582], "mapped", [1605, 1581]], [[64583, 64583], "mapped", [1605, 1582]], [[64584, 64584], "mapped", [1605, 1605]], [[64585, 64585], "mapped", [1605, 1609]], [[64586, 64586], "mapped", [1605, 1610]], [[64587, 64587], "mapped", [1606, 1580]], [[64588, 64588], "mapped", [1606, 1581]], [[64589, 64589], "mapped", [1606, 1582]], [[64590, 64590], "mapped", [1606, 1605]], [[64591, 64591], "mapped", [1606, 1609]], [[64592, 64592], "mapped", [1606, 1610]], [[64593, 64593], "mapped", [1607, 1580]], [[64594, 64594], "mapped", [1607, 1605]], [[64595, 64595], "mapped", [1607, 1609]], [[64596, 64596], "mapped", [1607, 1610]], [[64597, 64597], "mapped", [1610, 1580]], [[64598, 64598], "mapped", [1610, 1581]], [[64599, 64599], "mapped", [1610, 1582]], [[64600, 64600], "mapped", [1610, 1605]], [[64601, 64601], "mapped", [1610, 1609]], [[64602, 64602], "mapped", [1610, 1610]], [[64603, 64603], "mapped", [1584, 1648]], [[64604, 64604], "mapped", [1585, 1648]], [[64605, 64605], "mapped", [1609, 1648]], [[64606, 64606], "disallowed_STD3_mapped", [32, 1612, 1617]], [[64607, 64607], "disallowed_STD3_mapped", [32, 1613, 1617]], [[64608, 64608], "disallowed_STD3_mapped", [32, 1614, 1617]], [[64609, 64609], "disallowed_STD3_mapped", [32, 1615, 1617]], [[64610, 64610], "disallowed_STD3_mapped", [32, 1616, 1617]], [[64611, 64611], "disallowed_STD3_mapped", [32, 1617, 1648]], [[64612, 64612], "mapped", [1574, 1585]], [[64613, 64613], "mapped", [1574, 1586]], [[64614, 64614], "mapped", [1574, 1605]], [[64615, 64615], "mapped", [1574, 1606]], [[64616, 64616], "mapped", [1574, 1609]], [[64617, 64617], "mapped", [1574, 1610]], [[64618, 64618], "mapped", [1576, 1585]], [[64619, 64619], "mapped", [1576, 1586]], [[64620, 64620], "mapped", [1576, 1605]], [[64621, 64621], "mapped", [1576, 1606]], [[64622, 64622], "mapped", [1576, 1609]], [[64623, 64623], "mapped", [1576, 1610]], [[64624, 64624], "mapped", [1578, 1585]], [[64625, 64625], "mapped", [1578, 1586]], [[64626, 64626], "mapped", [1578, 1605]], [[64627, 64627], "mapped", [1578, 1606]], [[64628, 64628], "mapped", [1578, 1609]], [[64629, 64629], "mapped", [1578, 1610]], [[64630, 64630], "mapped", [1579, 1585]], [[64631, 64631], "mapped", [1579, 1586]], [[64632, 64632], "mapped", [1579, 1605]], [[64633, 64633], "mapped", [1579, 1606]], [[64634, 64634], "mapped", [1579, 1609]], [[64635, 64635], "mapped", [1579, 1610]], [[64636, 64636], "mapped", [1601, 1609]], [[64637, 64637], "mapped", [1601, 1610]], [[64638, 64638], "mapped", [1602, 1609]], [[64639, 64639], "mapped", [1602, 1610]], [[64640, 64640], "mapped", [1603, 1575]], [[64641, 64641], "mapped", [1603, 1604]], [[64642, 64642], "mapped", [1603, 1605]], [[64643, 64643], "mapped", [1603, 1609]], [[64644, 64644], "mapped", [1603, 1610]], [[64645, 64645], "mapped", [1604, 1605]], [[64646, 64646], "mapped", [1604, 1609]], [[64647, 64647], "mapped", [1604, 1610]], [[64648, 64648], "mapped", [1605, 1575]], [[64649, 64649], "mapped", [1605, 1605]], [[64650, 64650], "mapped", [1606, 1585]], [[64651, 64651], "mapped", [1606, 1586]], [[64652, 64652], "mapped", [1606, 1605]], [[64653, 64653], "mapped", [1606, 1606]], [[64654, 64654], "mapped", [1606, 1609]], [[64655, 64655], "mapped", [1606, 1610]], [[64656, 64656], "mapped", [1609, 1648]], [[64657, 64657], "mapped", [1610, 1585]], [[64658, 64658], "mapped", [1610, 1586]], [[64659, 64659], "mapped", [1610, 1605]], [[64660, 64660], "mapped", [1610, 1606]], [[64661, 64661], "mapped", [1610, 1609]], [[64662, 64662], "mapped", [1610, 1610]], [[64663, 64663], "mapped", [1574, 1580]], [[64664, 64664], "mapped", [1574, 1581]], [[64665, 64665], "mapped", [1574, 1582]], [[64666, 64666], "mapped", [1574, 1605]], [[64667, 64667], "mapped", [1574, 1607]], [[64668, 64668], "mapped", [1576, 1580]], [[64669, 64669], "mapped", [1576, 1581]], [[64670, 64670], "mapped", [1576, 1582]], [[64671, 64671], "mapped", [1576, 1605]], [[64672, 64672], "mapped", [1576, 1607]], [[64673, 64673], "mapped", [1578, 1580]], [[64674, 64674], "mapped", [1578, 1581]], [[64675, 64675], "mapped", [1578, 1582]], [[64676, 64676], "mapped", [1578, 1605]], [[64677, 64677], "mapped", [1578, 1607]], [[64678, 64678], "mapped", [1579, 1605]], [[64679, 64679], "mapped", [1580, 1581]], [[64680, 64680], "mapped", [1580, 1605]], [[64681, 64681], "mapped", [1581, 1580]], [[64682, 64682], "mapped", [1581, 1605]], [[64683, 64683], "mapped", [1582, 1580]], [[64684, 64684], "mapped", [1582, 1605]], [[64685, 64685], "mapped", [1587, 1580]], [[64686, 64686], "mapped", [1587, 1581]], [[64687, 64687], "mapped", [1587, 1582]], [[64688, 64688], "mapped", [1587, 1605]], [[64689, 64689], "mapped", [1589, 1581]], [[64690, 64690], "mapped", [1589, 1582]], [[64691, 64691], "mapped", [1589, 1605]], [[64692, 64692], "mapped", [1590, 1580]], [[64693, 64693], "mapped", [1590, 1581]], [[64694, 64694], "mapped", [1590, 1582]], [[64695, 64695], "mapped", [1590, 1605]], [[64696, 64696], "mapped", [1591, 1581]], [[64697, 64697], "mapped", [1592, 1605]], [[64698, 64698], "mapped", [1593, 1580]], [[64699, 64699], "mapped", [1593, 1605]], [[64700, 64700], "mapped", [1594, 1580]], [[64701, 64701], "mapped", [1594, 1605]], [[64702, 64702], "mapped", [1601, 1580]], [[64703, 64703], "mapped", [1601, 1581]], [[64704, 64704], "mapped", [1601, 1582]], [[64705, 64705], "mapped", [1601, 1605]], [[64706, 64706], "mapped", [1602, 1581]], [[64707, 64707], "mapped", [1602, 1605]], [[64708, 64708], "mapped", [1603, 1580]], [[64709, 64709], "mapped", [1603, 1581]], [[64710, 64710], "mapped", [1603, 1582]], [[64711, 64711], "mapped", [1603, 1604]], [[64712, 64712], "mapped", [1603, 1605]], [[64713, 64713], "mapped", [1604, 1580]], [[64714, 64714], "mapped", [1604, 1581]], [[64715, 64715], "mapped", [1604, 1582]], [[64716, 64716], "mapped", [1604, 1605]], [[64717, 64717], "mapped", [1604, 1607]], [[64718, 64718], "mapped", [1605, 1580]], [[64719, 64719], "mapped", [1605, 1581]], [[64720, 64720], "mapped", [1605, 1582]], [[64721, 64721], "mapped", [1605, 1605]], [[64722, 64722], "mapped", [1606, 1580]], [[64723, 64723], "mapped", [1606, 1581]], [[64724, 64724], "mapped", [1606, 1582]], [[64725, 64725], "mapped", [1606, 1605]], [[64726, 64726], "mapped", [1606, 1607]], [[64727, 64727], "mapped", [1607, 1580]], [[64728, 64728], "mapped", [1607, 1605]], [[64729, 64729], "mapped", [1607, 1648]], [[64730, 64730], "mapped", [1610, 1580]], [[64731, 64731], "mapped", [1610, 1581]], [[64732, 64732], "mapped", [1610, 1582]], [[64733, 64733], "mapped", [1610, 1605]], [[64734, 64734], "mapped", [1610, 1607]], [[64735, 64735], "mapped", [1574, 1605]], [[64736, 64736], "mapped", [1574, 1607]], [[64737, 64737], "mapped", [1576, 1605]], [[64738, 64738], "mapped", [1576, 1607]], [[64739, 64739], "mapped", [1578, 1605]], [[64740, 64740], "mapped", [1578, 1607]], [[64741, 64741], "mapped", [1579, 1605]], [[64742, 64742], "mapped", [1579, 1607]], [[64743, 64743], "mapped", [1587, 1605]], [[64744, 64744], "mapped", [1587, 1607]], [[64745, 64745], "mapped", [1588, 1605]], [[64746, 64746], "mapped", [1588, 1607]], [[64747, 64747], "mapped", [1603, 1604]], [[64748, 64748], "mapped", [1603, 1605]], [[64749, 64749], "mapped", [1604, 1605]], [[64750, 64750], "mapped", [1606, 1605]], [[64751, 64751], "mapped", [1606, 1607]], [[64752, 64752], "mapped", [1610, 1605]], [[64753, 64753], "mapped", [1610, 1607]], [[64754, 64754], "mapped", [1600, 1614, 1617]], [[64755, 64755], "mapped", [1600, 1615, 1617]], [[64756, 64756], "mapped", [1600, 1616, 1617]], [[64757, 64757], "mapped", [1591, 1609]], [[64758, 64758], "mapped", [1591, 1610]], [[64759, 64759], "mapped", [1593, 1609]], [[64760, 64760], "mapped", [1593, 1610]], [[64761, 64761], "mapped", [1594, 1609]], [[64762, 64762], "mapped", [1594, 1610]], [[64763, 64763], "mapped", [1587, 1609]], [[64764, 64764], "mapped", [1587, 1610]], [[64765, 64765], "mapped", [1588, 1609]], [[64766, 64766], "mapped", [1588, 1610]], [[64767, 64767], "mapped", [1581, 1609]], [[64768, 64768], "mapped", [1581, 1610]], [[64769, 64769], "mapped", [1580, 1609]], [[64770, 64770], "mapped", [1580, 1610]], [[64771, 64771], "mapped", [1582, 1609]], [[64772, 64772], "mapped", [1582, 1610]], [[64773, 64773], "mapped", [1589, 1609]], [[64774, 64774], "mapped", [1589, 1610]], [[64775, 64775], "mapped", [1590, 1609]], [[64776, 64776], "mapped", [1590, 1610]], [[64777, 64777], "mapped", [1588, 1580]], [[64778, 64778], "mapped", [1588, 1581]], [[64779, 64779], "mapped", [1588, 1582]], [[64780, 64780], "mapped", [1588, 1605]], [[64781, 64781], "mapped", [1588, 1585]], [[64782, 64782], "mapped", [1587, 1585]], [[64783, 64783], "mapped", [1589, 1585]], [[64784, 64784], "mapped", [1590, 1585]], [[64785, 64785], "mapped", [1591, 1609]], [[64786, 64786], "mapped", [1591, 1610]], [[64787, 64787], "mapped", [1593, 1609]], [[64788, 64788], "mapped", [1593, 1610]], [[64789, 64789], "mapped", [1594, 1609]], [[64790, 64790], "mapped", [1594, 1610]], [[64791, 64791], "mapped", [1587, 1609]], [[64792, 64792], "mapped", [1587, 1610]], [[64793, 64793], "mapped", [1588, 1609]], [[64794, 64794], "mapped", [1588, 1610]], [[64795, 64795], "mapped", [1581, 1609]], [[64796, 64796], "mapped", [1581, 1610]], [[64797, 64797], "mapped", [1580, 1609]], [[64798, 64798], "mapped", [1580, 1610]], [[64799, 64799], "mapped", [1582, 1609]], [[64800, 64800], "mapped", [1582, 1610]], [[64801, 64801], "mapped", [1589, 1609]], [[64802, 64802], "mapped", [1589, 1610]], [[64803, 64803], "mapped", [1590, 1609]], [[64804, 64804], "mapped", [1590, 1610]], [[64805, 64805], "mapped", [1588, 1580]], [[64806, 64806], "mapped", [1588, 1581]], [[64807, 64807], "mapped", [1588, 1582]], [[64808, 64808], "mapped", [1588, 1605]], [[64809, 64809], "mapped", [1588, 1585]], [[64810, 64810], "mapped", [1587, 1585]], [[64811, 64811], "mapped", [1589, 1585]], [[64812, 64812], "mapped", [1590, 1585]], [[64813, 64813], "mapped", [1588, 1580]], [[64814, 64814], "mapped", [1588, 1581]], [[64815, 64815], "mapped", [1588, 1582]], [[64816, 64816], "mapped", [1588, 1605]], [[64817, 64817], "mapped", [1587, 1607]], [[64818, 64818], "mapped", [1588, 1607]], [[64819, 64819], "mapped", [1591, 1605]], [[64820, 64820], "mapped", [1587, 1580]], [[64821, 64821], "mapped", [1587, 1581]], [[64822, 64822], "mapped", [1587, 1582]], [[64823, 64823], "mapped", [1588, 1580]], [[64824, 64824], "mapped", [1588, 1581]], [[64825, 64825], "mapped", [1588, 1582]], [[64826, 64826], "mapped", [1591, 1605]], [[64827, 64827], "mapped", [1592, 1605]], [[64828, 64829], "mapped", [1575, 1611]], [[64830, 64831], "valid", [], "NV8"], [[64832, 64847], "disallowed"], [[64848, 64848], "mapped", [1578, 1580, 1605]], [[64849, 64850], "mapped", [1578, 1581, 1580]], [[64851, 64851], "mapped", [1578, 1581, 1605]], [[64852, 64852], "mapped", [1578, 1582, 1605]], [[64853, 64853], "mapped", [1578, 1605, 1580]], [[64854, 64854], "mapped", [1578, 1605, 1581]], [[64855, 64855], "mapped", [1578, 1605, 1582]], [[64856, 64857], "mapped", [1580, 1605, 1581]], [[64858, 64858], "mapped", [1581, 1605, 1610]], [[64859, 64859], "mapped", [1581, 1605, 1609]], [[64860, 64860], "mapped", [1587, 1581, 1580]], [[64861, 64861], "mapped", [1587, 1580, 1581]], [[64862, 64862], "mapped", [1587, 1580, 1609]], [[64863, 64864], "mapped", [1587, 1605, 1581]], [[64865, 64865], "mapped", [1587, 1605, 1580]], [[64866, 64867], "mapped", [1587, 1605, 1605]], [[64868, 64869], "mapped", [1589, 1581, 1581]], [[64870, 64870], "mapped", [1589, 1605, 1605]], [[64871, 64872], "mapped", [1588, 1581, 1605]], [[64873, 64873], "mapped", [1588, 1580, 1610]], [[64874, 64875], "mapped", [1588, 1605, 1582]], [[64876, 64877], "mapped", [1588, 1605, 1605]], [[64878, 64878], "mapped", [1590, 1581, 1609]], [[64879, 64880], "mapped", [1590, 1582, 1605]], [[64881, 64882], "mapped", [1591, 1605, 1581]], [[64883, 64883], "mapped", [1591, 1605, 1605]], [[64884, 64884], "mapped", [1591, 1605, 1610]], [[64885, 64885], "mapped", [1593, 1580, 1605]], [[64886, 64887], "mapped", [1593, 1605, 1605]], [[64888, 64888], "mapped", [1593, 1605, 1609]], [[64889, 64889], "mapped", [1594, 1605, 1605]], [[64890, 64890], "mapped", [1594, 1605, 1610]], [[64891, 64891], "mapped", [1594, 1605, 1609]], [[64892, 64893], "mapped", [1601, 1582, 1605]], [[64894, 64894], "mapped", [1602, 1605, 1581]], [[64895, 64895], "mapped", [1602, 1605, 1605]], [[64896, 64896], "mapped", [1604, 1581, 1605]], [[64897, 64897], "mapped", [1604, 1581, 1610]], [[64898, 64898], "mapped", [1604, 1581, 1609]], [[64899, 64900], "mapped", [1604, 1580, 1580]], [[64901, 64902], "mapped", [1604, 1582, 1605]], [[64903, 64904], "mapped", [1604, 1605, 1581]], [[64905, 64905], "mapped", [1605, 1581, 1580]], [[64906, 64906], "mapped", [1605, 1581, 1605]], [[64907, 64907], "mapped", [1605, 1581, 1610]], [[64908, 64908], "mapped", [1605, 1580, 1581]], [[64909, 64909], "mapped", [1605, 1580, 1605]], [[64910, 64910], "mapped", [1605, 1582, 1580]], [[64911, 64911], "mapped", [1605, 1582, 1605]], [[64912, 64913], "disallowed"], [[64914, 64914], "mapped", [1605, 1580, 1582]], [[64915, 64915], "mapped", [1607, 1605, 1580]], [[64916, 64916], "mapped", [1607, 1605, 1605]], [[64917, 64917], "mapped", [1606, 1581, 1605]], [[64918, 64918], "mapped", [1606, 1581, 1609]], [[64919, 64920], "mapped", [1606, 1580, 1605]], [[64921, 64921], "mapped", [1606, 1580, 1609]], [[64922, 64922], "mapped", [1606, 1605, 1610]], [[64923, 64923], "mapped", [1606, 1605, 1609]], [[64924, 64925], "mapped", [1610, 1605, 1605]], [[64926, 64926], "mapped", [1576, 1582, 1610]], [[64927, 64927], "mapped", [1578, 1580, 1610]], [[64928, 64928], "mapped", [1578, 1580, 1609]], [[64929, 64929], "mapped", [1578, 1582, 1610]], [[64930, 64930], "mapped", [1578, 1582, 1609]], [[64931, 64931], "mapped", [1578, 1605, 1610]], [[64932, 64932], "mapped", [1578, 1605, 1609]], [[64933, 64933], "mapped", [1580, 1605, 1610]], [[64934, 64934], "mapped", [1580, 1581, 1609]], [[64935, 64935], "mapped", [1580, 1605, 1609]], [[64936, 64936], "mapped", [1587, 1582, 1609]], [[64937, 64937], "mapped", [1589, 1581, 1610]], [[64938, 64938], "mapped", [1588, 1581, 1610]], [[64939, 64939], "mapped", [1590, 1581, 1610]], [[64940, 64940], "mapped", [1604, 1580, 1610]], [[64941, 64941], "mapped", [1604, 1605, 1610]], [[64942, 64942], "mapped", [1610, 1581, 1610]], [[64943, 64943], "mapped", [1610, 1580, 1610]], [[64944, 64944], "mapped", [1610, 1605, 1610]], [[64945, 64945], "mapped", [1605, 1605, 1610]], [[64946, 64946], "mapped", [1602, 1605, 1610]], [[64947, 64947], "mapped", [1606, 1581, 1610]], [[64948, 64948], "mapped", [1602, 1605, 1581]], [[64949, 64949], "mapped", [1604, 1581, 1605]], [[64950, 64950], "mapped", [1593, 1605, 1610]], [[64951, 64951], "mapped", [1603, 1605, 1610]], [[64952, 64952], "mapped", [1606, 1580, 1581]], [[64953, 64953], "mapped", [1605, 1582, 1610]], [[64954, 64954], "mapped", [1604, 1580, 1605]], [[64955, 64955], "mapped", [1603, 1605, 1605]], [[64956, 64956], "mapped", [1604, 1580, 1605]], [[64957, 64957], "mapped", [1606, 1580, 1581]], [[64958, 64958], "mapped", [1580, 1581, 1610]], [[64959, 64959], "mapped", [1581, 1580, 1610]], [[64960, 64960], "mapped", [1605, 1580, 1610]], [[64961, 64961], "mapped", [1601, 1605, 1610]], [[64962, 64962], "mapped", [1576, 1581, 1610]], [[64963, 64963], "mapped", [1603, 1605, 1605]], [[64964, 64964], "mapped", [1593, 1580, 1605]], [[64965, 64965], "mapped", [1589, 1605, 1605]], [[64966, 64966], "mapped", [1587, 1582, 1610]], [[64967, 64967], "mapped", [1606, 1580, 1610]], [[64968, 64975], "disallowed"], [[64976, 65007], "disallowed"], [[65008, 65008], "mapped", [1589, 1604, 1746]], [[65009, 65009], "mapped", [1602, 1604, 1746]], [[65010, 65010], "mapped", [1575, 1604, 1604, 1607]], [[65011, 65011], "mapped", [1575, 1603, 1576, 1585]], [[65012, 65012], "mapped", [1605, 1581, 1605, 1583]], [[65013, 65013], "mapped", [1589, 1604, 1593, 1605]], [[65014, 65014], "mapped", [1585, 1587, 1608, 1604]], [[65015, 65015], "mapped", [1593, 1604, 1610, 1607]], [[65016, 65016], "mapped", [1608, 1587, 1604, 1605]], [[65017, 65017], "mapped", [1589, 1604, 1609]], [[65018, 65018], "disallowed_STD3_mapped", [1589, 1604, 1609, 32, 1575, 1604, 1604, 1607, 32, 1593, 1604, 1610, 1607, 32, 1608, 1587, 1604, 1605]], [[65019, 65019], "disallowed_STD3_mapped", [1580, 1604, 32, 1580, 1604, 1575, 1604, 1607]], [[65020, 65020], "mapped", [1585, 1740, 1575, 1604]], [[65021, 65021], "valid", [], "NV8"], [[65022, 65023], "disallowed"], [[65024, 65039], "ignored"], [[65040, 65040], "disallowed_STD3_mapped", [44]], [[65041, 65041], "mapped", [12289]], [[65042, 65042], "disallowed"], [[65043, 65043], "disallowed_STD3_mapped", [58]], [[65044, 65044], "disallowed_STD3_mapped", [59]], [[65045, 65045], "disallowed_STD3_mapped", [33]], [[65046, 65046], "disallowed_STD3_mapped", [63]], [[65047, 65047], "mapped", [12310]], [[65048, 65048], "mapped", [12311]], [[65049, 65049], "disallowed"], [[65050, 65055], "disallowed"], [[65056, 65059], "valid"], [[65060, 65062], "valid"], [[65063, 65069], "valid"], [[65070, 65071], "valid"], [[65072, 65072], "disallowed"], [[65073, 65073], "mapped", [8212]], [[65074, 65074], "mapped", [8211]], [[65075, 65076], "disallowed_STD3_mapped", [95]], [[65077, 65077], "disallowed_STD3_mapped", [40]], [[65078, 65078], "disallowed_STD3_mapped", [41]], [[65079, 65079], "disallowed_STD3_mapped", [123]], [[65080, 65080], "disallowed_STD3_mapped", [125]], [[65081, 65081], "mapped", [12308]], [[65082, 65082], "mapped", [12309]], [[65083, 65083], "mapped", [12304]], [[65084, 65084], "mapped", [12305]], [[65085, 65085], "mapped", [12298]], [[65086, 65086], "mapped", [12299]], [[65087, 65087], "mapped", [12296]], [[65088, 65088], "mapped", [12297]], [[65089, 65089], "mapped", [12300]], [[65090, 65090], "mapped", [12301]], [[65091, 65091], "mapped", [12302]], [[65092, 65092], "mapped", [12303]], [[65093, 65094], "valid", [], "NV8"], [[65095, 65095], "disallowed_STD3_mapped", [91]], [[65096, 65096], "disallowed_STD3_mapped", [93]], [[65097, 65100], "disallowed_STD3_mapped", [32, 773]], [[65101, 65103], "disallowed_STD3_mapped", [95]], [[65104, 65104], "disallowed_STD3_mapped", [44]], [[65105, 65105], "mapped", [12289]], [[65106, 65106], "disallowed"], [[65107, 65107], "disallowed"], [[65108, 65108], "disallowed_STD3_mapped", [59]], [[65109, 65109], "disallowed_STD3_mapped", [58]], [[65110, 65110], "disallowed_STD3_mapped", [63]], [[65111, 65111], "disallowed_STD3_mapped", [33]], [[65112, 65112], "mapped", [8212]], [[65113, 65113], "disallowed_STD3_mapped", [40]], [[65114, 65114], "disallowed_STD3_mapped", [41]], [[65115, 65115], "disallowed_STD3_mapped", [123]], [[65116, 65116], "disallowed_STD3_mapped", [125]], [[65117, 65117], "mapped", [12308]], [[65118, 65118], "mapped", [12309]], [[65119, 65119], "disallowed_STD3_mapped", [35]], [[65120, 65120], "disallowed_STD3_mapped", [38]], [[65121, 65121], "disallowed_STD3_mapped", [42]], [[65122, 65122], "disallowed_STD3_mapped", [43]], [[65123, 65123], "mapped", [45]], [[65124, 65124], "disallowed_STD3_mapped", [60]], [[65125, 65125], "disallowed_STD3_mapped", [62]], [[65126, 65126], "disallowed_STD3_mapped", [61]], [[65127, 65127], "disallowed"], [[65128, 65128], "disallowed_STD3_mapped", [92]], [[65129, 65129], "disallowed_STD3_mapped", [36]], [[65130, 65130], "disallowed_STD3_mapped", [37]], [[65131, 65131], "disallowed_STD3_mapped", [64]], [[65132, 65135], "disallowed"], [[65136, 65136], "disallowed_STD3_mapped", [32, 1611]], [[65137, 65137], "mapped", [1600, 1611]], [[65138, 65138], "disallowed_STD3_mapped", [32, 1612]], [[65139, 65139], "valid"], [[65140, 65140], "disallowed_STD3_mapped", [32, 1613]], [[65141, 65141], "disallowed"], [[65142, 65142], "disallowed_STD3_mapped", [32, 1614]], [[65143, 65143], "mapped", [1600, 1614]], [[65144, 65144], "disallowed_STD3_mapped", [32, 1615]], [[65145, 65145], "mapped", [1600, 1615]], [[65146, 65146], "disallowed_STD3_mapped", [32, 1616]], [[65147, 65147], "mapped", [1600, 1616]], [[65148, 65148], "disallowed_STD3_mapped", [32, 1617]], [[65149, 65149], "mapped", [1600, 1617]], [[65150, 65150], "disallowed_STD3_mapped", [32, 1618]], [[65151, 65151], "mapped", [1600, 1618]], [[65152, 65152], "mapped", [1569]], [[65153, 65154], "mapped", [1570]], [[65155, 65156], "mapped", [1571]], [[65157, 65158], "mapped", [1572]], [[65159, 65160], "mapped", [1573]], [[65161, 65164], "mapped", [1574]], [[65165, 65166], "mapped", [1575]], [[65167, 65170], "mapped", [1576]], [[65171, 65172], "mapped", [1577]], [[65173, 65176], "mapped", [1578]], [[65177, 65180], "mapped", [1579]], [[65181, 65184], "mapped", [1580]], [[65185, 65188], "mapped", [1581]], [[65189, 65192], "mapped", [1582]], [[65193, 65194], "mapped", [1583]], [[65195, 65196], "mapped", [1584]], [[65197, 65198], "mapped", [1585]], [[65199, 65200], "mapped", [1586]], [[65201, 65204], "mapped", [1587]], [[65205, 65208], "mapped", [1588]], [[65209, 65212], "mapped", [1589]], [[65213, 65216], "mapped", [1590]], [[65217, 65220], "mapped", [1591]], [[65221, 65224], "mapped", [1592]], [[65225, 65228], "mapped", [1593]], [[65229, 65232], "mapped", [1594]], [[65233, 65236], "mapped", [1601]], [[65237, 65240], "mapped", [1602]], [[65241, 65244], "mapped", [1603]], [[65245, 65248], "mapped", [1604]], [[65249, 65252], "mapped", [1605]], [[65253, 65256], "mapped", [1606]], [[65257, 65260], "mapped", [1607]], [[65261, 65262], "mapped", [1608]], [[65263, 65264], "mapped", [1609]], [[65265, 65268], "mapped", [1610]], [[65269, 65270], "mapped", [1604, 1570]], [[65271, 65272], "mapped", [1604, 1571]], [[65273, 65274], "mapped", [1604, 1573]], [[65275, 65276], "mapped", [1604, 1575]], [[65277, 65278], "disallowed"], [[65279, 65279], "ignored"], [[65280, 65280], "disallowed"], [[65281, 65281], "disallowed_STD3_mapped", [33]], [[65282, 65282], "disallowed_STD3_mapped", [34]], [[65283, 65283], "disallowed_STD3_mapped", [35]], [[65284, 65284], "disallowed_STD3_mapped", [36]], [[65285, 65285], "disallowed_STD3_mapped", [37]], [[65286, 65286], "disallowed_STD3_mapped", [38]], [[65287, 65287], "disallowed_STD3_mapped", [39]], [[65288, 65288], "disallowed_STD3_mapped", [40]], [[65289, 65289], "disallowed_STD3_mapped", [41]], [[65290, 65290], "disallowed_STD3_mapped", [42]], [[65291, 65291], "disallowed_STD3_mapped", [43]], [[65292, 65292], "disallowed_STD3_mapped", [44]], [[65293, 65293], "mapped", [45]], [[65294, 65294], "mapped", [46]], [[65295, 65295], "disallowed_STD3_mapped", [47]], [[65296, 65296], "mapped", [48]], [[65297, 65297], "mapped", [49]], [[65298, 65298], "mapped", [50]], [[65299, 65299], "mapped", [51]], [[65300, 65300], "mapped", [52]], [[65301, 65301], "mapped", [53]], [[65302, 65302], "mapped", [54]], [[65303, 65303], "mapped", [55]], [[65304, 65304], "mapped", [56]], [[65305, 65305], "mapped", [57]], [[65306, 65306], "disallowed_STD3_mapped", [58]], [[65307, 65307], "disallowed_STD3_mapped", [59]], [[65308, 65308], "disallowed_STD3_mapped", [60]], [[65309, 65309], "disallowed_STD3_mapped", [61]], [[65310, 65310], "disallowed_STD3_mapped", [62]], [[65311, 65311], "disallowed_STD3_mapped", [63]], [[65312, 65312], "disallowed_STD3_mapped", [64]], [[65313, 65313], "mapped", [97]], [[65314, 65314], "mapped", [98]], [[65315, 65315], "mapped", [99]], [[65316, 65316], "mapped", [100]], [[65317, 65317], "mapped", [101]], [[65318, 65318], "mapped", [102]], [[65319, 65319], "mapped", [103]], [[65320, 65320], "mapped", [104]], [[65321, 65321], "mapped", [105]], [[65322, 65322], "mapped", [106]], [[65323, 65323], "mapped", [107]], [[65324, 65324], "mapped", [108]], [[65325, 65325], "mapped", [109]], [[65326, 65326], "mapped", [110]], [[65327, 65327], "mapped", [111]], [[65328, 65328], "mapped", [112]], [[65329, 65329], "mapped", [113]], [[65330, 65330], "mapped", [114]], [[65331, 65331], "mapped", [115]], [[65332, 65332], "mapped", [116]], [[65333, 65333], "mapped", [117]], [[65334, 65334], "mapped", [118]], [[65335, 65335], "mapped", [119]], [[65336, 65336], "mapped", [120]], [[65337, 65337], "mapped", [121]], [[65338, 65338], "mapped", [122]], [[65339, 65339], "disallowed_STD3_mapped", [91]], [[65340, 65340], "disallowed_STD3_mapped", [92]], [[65341, 65341], "disallowed_STD3_mapped", [93]], [[65342, 65342], "disallowed_STD3_mapped", [94]], [[65343, 65343], "disallowed_STD3_mapped", [95]], [[65344, 65344], "disallowed_STD3_mapped", [96]], [[65345, 65345], "mapped", [97]], [[65346, 65346], "mapped", [98]], [[65347, 65347], "mapped", [99]], [[65348, 65348], "mapped", [100]], [[65349, 65349], "mapped", [101]], [[65350, 65350], "mapped", [102]], [[65351, 65351], "mapped", [103]], [[65352, 65352], "mapped", [104]], [[65353, 65353], "mapped", [105]], [[65354, 65354], "mapped", [106]], [[65355, 65355], "mapped", [107]], [[65356, 65356], "mapped", [108]], [[65357, 65357], "mapped", [109]], [[65358, 65358], "mapped", [110]], [[65359, 65359], "mapped", [111]], [[65360, 65360], "mapped", [112]], [[65361, 65361], "mapped", [113]], [[65362, 65362], "mapped", [114]], [[65363, 65363], "mapped", [115]], [[65364, 65364], "mapped", [116]], [[65365, 65365], "mapped", [117]], [[65366, 65366], "mapped", [118]], [[65367, 65367], "mapped", [119]], [[65368, 65368], "mapped", [120]], [[65369, 65369], "mapped", [121]], [[65370, 65370], "mapped", [122]], [[65371, 65371], "disallowed_STD3_mapped", [123]], [[65372, 65372], "disallowed_STD3_mapped", [124]], [[65373, 65373], "disallowed_STD3_mapped", [125]], [[65374, 65374], "disallowed_STD3_mapped", [126]], [[65375, 65375], "mapped", [10629]], [[65376, 65376], "mapped", [10630]], [[65377, 65377], "mapped", [46]], [[65378, 65378], "mapped", [12300]], [[65379, 65379], "mapped", [12301]], [[65380, 65380], "mapped", [12289]], [[65381, 65381], "mapped", [12539]], [[65382, 65382], "mapped", [12530]], [[65383, 65383], "mapped", [12449]], [[65384, 65384], "mapped", [12451]], [[65385, 65385], "mapped", [12453]], [[65386, 65386], "mapped", [12455]], [[65387, 65387], "mapped", [12457]], [[65388, 65388], "mapped", [12515]], [[65389, 65389], "mapped", [12517]], [[65390, 65390], "mapped", [12519]], [[65391, 65391], "mapped", [12483]], [[65392, 65392], "mapped", [12540]], [[65393, 65393], "mapped", [12450]], [[65394, 65394], "mapped", [12452]], [[65395, 65395], "mapped", [12454]], [[65396, 65396], "mapped", [12456]], [[65397, 65397], "mapped", [12458]], [[65398, 65398], "mapped", [12459]], [[65399, 65399], "mapped", [12461]], [[65400, 65400], "mapped", [12463]], [[65401, 65401], "mapped", [12465]], [[65402, 65402], "mapped", [12467]], [[65403, 65403], "mapped", [12469]], [[65404, 65404], "mapped", [12471]], [[65405, 65405], "mapped", [12473]], [[65406, 65406], "mapped", [12475]], [[65407, 65407], "mapped", [12477]], [[65408, 65408], "mapped", [12479]], [[65409, 65409], "mapped", [12481]], [[65410, 65410], "mapped", [12484]], [[65411, 65411], "mapped", [12486]], [[65412, 65412], "mapped", [12488]], [[65413, 65413], "mapped", [12490]], [[65414, 65414], "mapped", [12491]], [[65415, 65415], "mapped", [12492]], [[65416, 65416], "mapped", [12493]], [[65417, 65417], "mapped", [12494]], [[65418, 65418], "mapped", [12495]], [[65419, 65419], "mapped", [12498]], [[65420, 65420], "mapped", [12501]], [[65421, 65421], "mapped", [12504]], [[65422, 65422], "mapped", [12507]], [[65423, 65423], "mapped", [12510]], [[65424, 65424], "mapped", [12511]], [[65425, 65425], "mapped", [12512]], [[65426, 65426], "mapped", [12513]], [[65427, 65427], "mapped", [12514]], [[65428, 65428], "mapped", [12516]], [[65429, 65429], "mapped", [12518]], [[65430, 65430], "mapped", [12520]], [[65431, 65431], "mapped", [12521]], [[65432, 65432], "mapped", [12522]], [[65433, 65433], "mapped", [12523]], [[65434, 65434], "mapped", [12524]], [[65435, 65435], "mapped", [12525]], [[65436, 65436], "mapped", [12527]], [[65437, 65437], "mapped", [12531]], [[65438, 65438], "mapped", [12441]], [[65439, 65439], "mapped", [12442]], [[65440, 65440], "disallowed"], [[65441, 65441], "mapped", [4352]], [[65442, 65442], "mapped", [4353]], [[65443, 65443], "mapped", [4522]], [[65444, 65444], "mapped", [4354]], [[65445, 65445], "mapped", [4524]], [[65446, 65446], "mapped", [4525]], [[65447, 65447], "mapped", [4355]], [[65448, 65448], "mapped", [4356]], [[65449, 65449], "mapped", [4357]], [[65450, 65450], "mapped", [4528]], [[65451, 65451], "mapped", [4529]], [[65452, 65452], "mapped", [4530]], [[65453, 65453], "mapped", [4531]], [[65454, 65454], "mapped", [4532]], [[65455, 65455], "mapped", [4533]], [[65456, 65456], "mapped", [4378]], [[65457, 65457], "mapped", [4358]], [[65458, 65458], "mapped", [4359]], [[65459, 65459], "mapped", [4360]], [[65460, 65460], "mapped", [4385]], [[65461, 65461], "mapped", [4361]], [[65462, 65462], "mapped", [4362]], [[65463, 65463], "mapped", [4363]], [[65464, 65464], "mapped", [4364]], [[65465, 65465], "mapped", [4365]], [[65466, 65466], "mapped", [4366]], [[65467, 65467], "mapped", [4367]], [[65468, 65468], "mapped", [4368]], [[65469, 65469], "mapped", [4369]], [[65470, 65470], "mapped", [4370]], [[65471, 65473], "disallowed"], [[65474, 65474], "mapped", [4449]], [[65475, 65475], "mapped", [4450]], [[65476, 65476], "mapped", [4451]], [[65477, 65477], "mapped", [4452]], [[65478, 65478], "mapped", [4453]], [[65479, 65479], "mapped", [4454]], [[65480, 65481], "disallowed"], [[65482, 65482], "mapped", [4455]], [[65483, 65483], "mapped", [4456]], [[65484, 65484], "mapped", [4457]], [[65485, 65485], "mapped", [4458]], [[65486, 65486], "mapped", [4459]], [[65487, 65487], "mapped", [4460]], [[65488, 65489], "disallowed"], [[65490, 65490], "mapped", [4461]], [[65491, 65491], "mapped", [4462]], [[65492, 65492], "mapped", [4463]], [[65493, 65493], "mapped", [4464]], [[65494, 65494], "mapped", [4465]], [[65495, 65495], "mapped", [4466]], [[65496, 65497], "disallowed"], [[65498, 65498], "mapped", [4467]], [[65499, 65499], "mapped", [4468]], [[65500, 65500], "mapped", [4469]], [[65501, 65503], "disallowed"], [[65504, 65504], "mapped", [162]], [[65505, 65505], "mapped", [163]], [[65506, 65506], "mapped", [172]], [[65507, 65507], "disallowed_STD3_mapped", [32, 772]], [[65508, 65508], "mapped", [166]], [[65509, 65509], "mapped", [165]], [[65510, 65510], "mapped", [8361]], [[65511, 65511], "disallowed"], [[65512, 65512], "mapped", [9474]], [[65513, 65513], "mapped", [8592]], [[65514, 65514], "mapped", [8593]], [[65515, 65515], "mapped", [8594]], [[65516, 65516], "mapped", [8595]], [[65517, 65517], "mapped", [9632]], [[65518, 65518], "mapped", [9675]], [[65519, 65528], "disallowed"], [[65529, 65531], "disallowed"], [[65532, 65532], "disallowed"], [[65533, 65533], "disallowed"], [[65534, 65535], "disallowed"], [[65536, 65547], "valid"], [[65548, 65548], "disallowed"], [[65549, 65574], "valid"], [[65575, 65575], "disallowed"], [[65576, 65594], "valid"], [[65595, 65595], "disallowed"], [[65596, 65597], "valid"], [[65598, 65598], "disallowed"], [[65599, 65613], "valid"], [[65614, 65615], "disallowed"], [[65616, 65629], "valid"], [[65630, 65663], "disallowed"], [[65664, 65786], "valid"], [[65787, 65791], "disallowed"], [[65792, 65794], "valid", [], "NV8"], [[65795, 65798], "disallowed"], [[65799, 65843], "valid", [], "NV8"], [[65844, 65846], "disallowed"], [[65847, 65855], "valid", [], "NV8"], [[65856, 65930], "valid", [], "NV8"], [[65931, 65932], "valid", [], "NV8"], [[65933, 65935], "disallowed"], [[65936, 65947], "valid", [], "NV8"], [[65948, 65951], "disallowed"], [[65952, 65952], "valid", [], "NV8"], [[65953, 65999], "disallowed"], [[66000, 66044], "valid", [], "NV8"], [[66045, 66045], "valid"], [[66046, 66175], "disallowed"], [[66176, 66204], "valid"], [[66205, 66207], "disallowed"], [[66208, 66256], "valid"], [[66257, 66271], "disallowed"], [[66272, 66272], "valid"], [[66273, 66299], "valid", [], "NV8"], [[66300, 66303], "disallowed"], [[66304, 66334], "valid"], [[66335, 66335], "valid"], [[66336, 66339], "valid", [], "NV8"], [[66340, 66351], "disallowed"], [[66352, 66368], "valid"], [[66369, 66369], "valid", [], "NV8"], [[66370, 66377], "valid"], [[66378, 66378], "valid", [], "NV8"], [[66379, 66383], "disallowed"], [[66384, 66426], "valid"], [[66427, 66431], "disallowed"], [[66432, 66461], "valid"], [[66462, 66462], "disallowed"], [[66463, 66463], "valid", [], "NV8"], [[66464, 66499], "valid"], [[66500, 66503], "disallowed"], [[66504, 66511], "valid"], [[66512, 66517], "valid", [], "NV8"], [[66518, 66559], "disallowed"], [[66560, 66560], "mapped", [66600]], [[66561, 66561], "mapped", [66601]], [[66562, 66562], "mapped", [66602]], [[66563, 66563], "mapped", [66603]], [[66564, 66564], "mapped", [66604]], [[66565, 66565], "mapped", [66605]], [[66566, 66566], "mapped", [66606]], [[66567, 66567], "mapped", [66607]], [[66568, 66568], "mapped", [66608]], [[66569, 66569], "mapped", [66609]], [[66570, 66570], "mapped", [66610]], [[66571, 66571], "mapped", [66611]], [[66572, 66572], "mapped", [66612]], [[66573, 66573], "mapped", [66613]], [[66574, 66574], "mapped", [66614]], [[66575, 66575], "mapped", [66615]], [[66576, 66576], "mapped", [66616]], [[66577, 66577], "mapped", [66617]], [[66578, 66578], "mapped", [66618]], [[66579, 66579], "mapped", [66619]], [[66580, 66580], "mapped", [66620]], [[66581, 66581], "mapped", [66621]], [[66582, 66582], "mapped", [66622]], [[66583, 66583], "mapped", [66623]], [[66584, 66584], "mapped", [66624]], [[66585, 66585], "mapped", [66625]], [[66586, 66586], "mapped", [66626]], [[66587, 66587], "mapped", [66627]], [[66588, 66588], "mapped", [66628]], [[66589, 66589], "mapped", [66629]], [[66590, 66590], "mapped", [66630]], [[66591, 66591], "mapped", [66631]], [[66592, 66592], "mapped", [66632]], [[66593, 66593], "mapped", [66633]], [[66594, 66594], "mapped", [66634]], [[66595, 66595], "mapped", [66635]], [[66596, 66596], "mapped", [66636]], [[66597, 66597], "mapped", [66637]], [[66598, 66598], "mapped", [66638]], [[66599, 66599], "mapped", [66639]], [[66600, 66637], "valid"], [[66638, 66717], "valid"], [[66718, 66719], "disallowed"], [[66720, 66729], "valid"], [[66730, 66815], "disallowed"], [[66816, 66855], "valid"], [[66856, 66863], "disallowed"], [[66864, 66915], "valid"], [[66916, 66926], "disallowed"], [[66927, 66927], "valid", [], "NV8"], [[66928, 67071], "disallowed"], [[67072, 67382], "valid"], [[67383, 67391], "disallowed"], [[67392, 67413], "valid"], [[67414, 67423], "disallowed"], [[67424, 67431], "valid"], [[67432, 67583], "disallowed"], [[67584, 67589], "valid"], [[67590, 67591], "disallowed"], [[67592, 67592], "valid"], [[67593, 67593], "disallowed"], [[67594, 67637], "valid"], [[67638, 67638], "disallowed"], [[67639, 67640], "valid"], [[67641, 67643], "disallowed"], [[67644, 67644], "valid"], [[67645, 67646], "disallowed"], [[67647, 67647], "valid"], [[67648, 67669], "valid"], [[67670, 67670], "disallowed"], [[67671, 67679], "valid", [], "NV8"], [[67680, 67702], "valid"], [[67703, 67711], "valid", [], "NV8"], [[67712, 67742], "valid"], [[67743, 67750], "disallowed"], [[67751, 67759], "valid", [], "NV8"], [[67760, 67807], "disallowed"], [[67808, 67826], "valid"], [[67827, 67827], "disallowed"], [[67828, 67829], "valid"], [[67830, 67834], "disallowed"], [[67835, 67839], "valid", [], "NV8"], [[67840, 67861], "valid"], [[67862, 67865], "valid", [], "NV8"], [[67866, 67867], "valid", [], "NV8"], [[67868, 67870], "disallowed"], [[67871, 67871], "valid", [], "NV8"], [[67872, 67897], "valid"], [[67898, 67902], "disallowed"], [[67903, 67903], "valid", [], "NV8"], [[67904, 67967], "disallowed"], [[67968, 68023], "valid"], [[68024, 68027], "disallowed"], [[68028, 68029], "valid", [], "NV8"], [[68030, 68031], "valid"], [[68032, 68047], "valid", [], "NV8"], [[68048, 68049], "disallowed"], [[68050, 68095], "valid", [], "NV8"], [[68096, 68099], "valid"], [[68100, 68100], "disallowed"], [[68101, 68102], "valid"], [[68103, 68107], "disallowed"], [[68108, 68115], "valid"], [[68116, 68116], "disallowed"], [[68117, 68119], "valid"], [[68120, 68120], "disallowed"], [[68121, 68147], "valid"], [[68148, 68151], "disallowed"], [[68152, 68154], "valid"], [[68155, 68158], "disallowed"], [[68159, 68159], "valid"], [[68160, 68167], "valid", [], "NV8"], [[68168, 68175], "disallowed"], [[68176, 68184], "valid", [], "NV8"], [[68185, 68191], "disallowed"], [[68192, 68220], "valid"], [[68221, 68223], "valid", [], "NV8"], [[68224, 68252], "valid"], [[68253, 68255], "valid", [], "NV8"], [[68256, 68287], "disallowed"], [[68288, 68295], "valid"], [[68296, 68296], "valid", [], "NV8"], [[68297, 68326], "valid"], [[68327, 68330], "disallowed"], [[68331, 68342], "valid", [], "NV8"], [[68343, 68351], "disallowed"], [[68352, 68405], "valid"], [[68406, 68408], "disallowed"], [[68409, 68415], "valid", [], "NV8"], [[68416, 68437], "valid"], [[68438, 68439], "disallowed"], [[68440, 68447], "valid", [], "NV8"], [[68448, 68466], "valid"], [[68467, 68471], "disallowed"], [[68472, 68479], "valid", [], "NV8"], [[68480, 68497], "valid"], [[68498, 68504], "disallowed"], [[68505, 68508], "valid", [], "NV8"], [[68509, 68520], "disallowed"], [[68521, 68527], "valid", [], "NV8"], [[68528, 68607], "disallowed"], [[68608, 68680], "valid"], [[68681, 68735], "disallowed"], [[68736, 68736], "mapped", [68800]], [[68737, 68737], "mapped", [68801]], [[68738, 68738], "mapped", [68802]], [[68739, 68739], "mapped", [68803]], [[68740, 68740], "mapped", [68804]], [[68741, 68741], "mapped", [68805]], [[68742, 68742], "mapped", [68806]], [[68743, 68743], "mapped", [68807]], [[68744, 68744], "mapped", [68808]], [[68745, 68745], "mapped", [68809]], [[68746, 68746], "mapped", [68810]], [[68747, 68747], "mapped", [68811]], [[68748, 68748], "mapped", [68812]], [[68749, 68749], "mapped", [68813]], [[68750, 68750], "mapped", [68814]], [[68751, 68751], "mapped", [68815]], [[68752, 68752], "mapped", [68816]], [[68753, 68753], "mapped", [68817]], [[68754, 68754], "mapped", [68818]], [[68755, 68755], "mapped", [68819]], [[68756, 68756], "mapped", [68820]], [[68757, 68757], "mapped", [68821]], [[68758, 68758], "mapped", [68822]], [[68759, 68759], "mapped", [68823]], [[68760, 68760], "mapped", [68824]], [[68761, 68761], "mapped", [68825]], [[68762, 68762], "mapped", [68826]], [[68763, 68763], "mapped", [68827]], [[68764, 68764], "mapped", [68828]], [[68765, 68765], "mapped", [68829]], [[68766, 68766], "mapped", [68830]], [[68767, 68767], "mapped", [68831]], [[68768, 68768], "mapped", [68832]], [[68769, 68769], "mapped", [68833]], [[68770, 68770], "mapped", [68834]], [[68771, 68771], "mapped", [68835]], [[68772, 68772], "mapped", [68836]], [[68773, 68773], "mapped", [68837]], [[68774, 68774], "mapped", [68838]], [[68775, 68775], "mapped", [68839]], [[68776, 68776], "mapped", [68840]], [[68777, 68777], "mapped", [68841]], [[68778, 68778], "mapped", [68842]], [[68779, 68779], "mapped", [68843]], [[68780, 68780], "mapped", [68844]], [[68781, 68781], "mapped", [68845]], [[68782, 68782], "mapped", [68846]], [[68783, 68783], "mapped", [68847]], [[68784, 68784], "mapped", [68848]], [[68785, 68785], "mapped", [68849]], [[68786, 68786], "mapped", [68850]], [[68787, 68799], "disallowed"], [[68800, 68850], "valid"], [[68851, 68857], "disallowed"], [[68858, 68863], "valid", [], "NV8"], [[68864, 69215], "disallowed"], [[69216, 69246], "valid", [], "NV8"], [[69247, 69631], "disallowed"], [[69632, 69702], "valid"], [[69703, 69709], "valid", [], "NV8"], [[69710, 69713], "disallowed"], [[69714, 69733], "valid", [], "NV8"], [[69734, 69743], "valid"], [[69744, 69758], "disallowed"], [[69759, 69759], "valid"], [[69760, 69818], "valid"], [[69819, 69820], "valid", [], "NV8"], [[69821, 69821], "disallowed"], [[69822, 69825], "valid", [], "NV8"], [[69826, 69839], "disallowed"], [[69840, 69864], "valid"], [[69865, 69871], "disallowed"], [[69872, 69881], "valid"], [[69882, 69887], "disallowed"], [[69888, 69940], "valid"], [[69941, 69941], "disallowed"], [[69942, 69951], "valid"], [[69952, 69955], "valid", [], "NV8"], [[69956, 69967], "disallowed"], [[69968, 70003], "valid"], [[70004, 70005], "valid", [], "NV8"], [[70006, 70006], "valid"], [[70007, 70015], "disallowed"], [[70016, 70084], "valid"], [[70085, 70088], "valid", [], "NV8"], [[70089, 70089], "valid", [], "NV8"], [[70090, 70092], "valid"], [[70093, 70093], "valid", [], "NV8"], [[70094, 70095], "disallowed"], [[70096, 70105], "valid"], [[70106, 70106], "valid"], [[70107, 70107], "valid", [], "NV8"], [[70108, 70108], "valid"], [[70109, 70111], "valid", [], "NV8"], [[70112, 70112], "disallowed"], [[70113, 70132], "valid", [], "NV8"], [[70133, 70143], "disallowed"], [[70144, 70161], "valid"], [[70162, 70162], "disallowed"], [[70163, 70199], "valid"], [[70200, 70205], "valid", [], "NV8"], [[70206, 70271], "disallowed"], [[70272, 70278], "valid"], [[70279, 70279], "disallowed"], [[70280, 70280], "valid"], [[70281, 70281], "disallowed"], [[70282, 70285], "valid"], [[70286, 70286], "disallowed"], [[70287, 70301], "valid"], [[70302, 70302], "disallowed"], [[70303, 70312], "valid"], [[70313, 70313], "valid", [], "NV8"], [[70314, 70319], "disallowed"], [[70320, 70378], "valid"], [[70379, 70383], "disallowed"], [[70384, 70393], "valid"], [[70394, 70399], "disallowed"], [[70400, 70400], "valid"], [[70401, 70403], "valid"], [[70404, 70404], "disallowed"], [[70405, 70412], "valid"], [[70413, 70414], "disallowed"], [[70415, 70416], "valid"], [[70417, 70418], "disallowed"], [[70419, 70440], "valid"], [[70441, 70441], "disallowed"], [[70442, 70448], "valid"], [[70449, 70449], "disallowed"], [[70450, 70451], "valid"], [[70452, 70452], "disallowed"], [[70453, 70457], "valid"], [[70458, 70459], "disallowed"], [[70460, 70468], "valid"], [[70469, 70470], "disallowed"], [[70471, 70472], "valid"], [[70473, 70474], "disallowed"], [[70475, 70477], "valid"], [[70478, 70479], "disallowed"], [[70480, 70480], "valid"], [[70481, 70486], "disallowed"], [[70487, 70487], "valid"], [[70488, 70492], "disallowed"], [[70493, 70499], "valid"], [[70500, 70501], "disallowed"], [[70502, 70508], "valid"], [[70509, 70511], "disallowed"], [[70512, 70516], "valid"], [[70517, 70783], "disallowed"], [[70784, 70853], "valid"], [[70854, 70854], "valid", [], "NV8"], [[70855, 70855], "valid"], [[70856, 70863], "disallowed"], [[70864, 70873], "valid"], [[70874, 71039], "disallowed"], [[71040, 71093], "valid"], [[71094, 71095], "disallowed"], [[71096, 71104], "valid"], [[71105, 71113], "valid", [], "NV8"], [[71114, 71127], "valid", [], "NV8"], [[71128, 71133], "valid"], [[71134, 71167], "disallowed"], [[71168, 71232], "valid"], [[71233, 71235], "valid", [], "NV8"], [[71236, 71236], "valid"], [[71237, 71247], "disallowed"], [[71248, 71257], "valid"], [[71258, 71295], "disallowed"], [[71296, 71351], "valid"], [[71352, 71359], "disallowed"], [[71360, 71369], "valid"], [[71370, 71423], "disallowed"], [[71424, 71449], "valid"], [[71450, 71452], "disallowed"], [[71453, 71467], "valid"], [[71468, 71471], "disallowed"], [[71472, 71481], "valid"], [[71482, 71487], "valid", [], "NV8"], [[71488, 71839], "disallowed"], [[71840, 71840], "mapped", [71872]], [[71841, 71841], "mapped", [71873]], [[71842, 71842], "mapped", [71874]], [[71843, 71843], "mapped", [71875]], [[71844, 71844], "mapped", [71876]], [[71845, 71845], "mapped", [71877]], [[71846, 71846], "mapped", [71878]], [[71847, 71847], "mapped", [71879]], [[71848, 71848], "mapped", [71880]], [[71849, 71849], "mapped", [71881]], [[71850, 71850], "mapped", [71882]], [[71851, 71851], "mapped", [71883]], [[71852, 71852], "mapped", [71884]], [[71853, 71853], "mapped", [71885]], [[71854, 71854], "mapped", [71886]], [[71855, 71855], "mapped", [71887]], [[71856, 71856], "mapped", [71888]], [[71857, 71857], "mapped", [71889]], [[71858, 71858], "mapped", [71890]], [[71859, 71859], "mapped", [71891]], [[71860, 71860], "mapped", [71892]], [[71861, 71861], "mapped", [71893]], [[71862, 71862], "mapped", [71894]], [[71863, 71863], "mapped", [71895]], [[71864, 71864], "mapped", [71896]], [[71865, 71865], "mapped", [71897]], [[71866, 71866], "mapped", [71898]], [[71867, 71867], "mapped", [71899]], [[71868, 71868], "mapped", [71900]], [[71869, 71869], "mapped", [71901]], [[71870, 71870], "mapped", [71902]], [[71871, 71871], "mapped", [71903]], [[71872, 71913], "valid"], [[71914, 71922], "valid", [], "NV8"], [[71923, 71934], "disallowed"], [[71935, 71935], "valid"], [[71936, 72383], "disallowed"], [[72384, 72440], "valid"], [[72441, 73727], "disallowed"], [[73728, 74606], "valid"], [[74607, 74648], "valid"], [[74649, 74649], "valid"], [[74650, 74751], "disallowed"], [[74752, 74850], "valid", [], "NV8"], [[74851, 74862], "valid", [], "NV8"], [[74863, 74863], "disallowed"], [[74864, 74867], "valid", [], "NV8"], [[74868, 74868], "valid", [], "NV8"], [[74869, 74879], "disallowed"], [[74880, 75075], "valid"], [[75076, 77823], "disallowed"], [[77824, 78894], "valid"], [[78895, 82943], "disallowed"], [[82944, 83526], "valid"], [[83527, 92159], "disallowed"], [[92160, 92728], "valid"], [[92729, 92735], "disallowed"], [[92736, 92766], "valid"], [[92767, 92767], "disallowed"], [[92768, 92777], "valid"], [[92778, 92781], "disallowed"], [[92782, 92783], "valid", [], "NV8"], [[92784, 92879], "disallowed"], [[92880, 92909], "valid"], [[92910, 92911], "disallowed"], [[92912, 92916], "valid"], [[92917, 92917], "valid", [], "NV8"], [[92918, 92927], "disallowed"], [[92928, 92982], "valid"], [[92983, 92991], "valid", [], "NV8"], [[92992, 92995], "valid"], [[92996, 92997], "valid", [], "NV8"], [[92998, 93007], "disallowed"], [[93008, 93017], "valid"], [[93018, 93018], "disallowed"], [[93019, 93025], "valid", [], "NV8"], [[93026, 93026], "disallowed"], [[93027, 93047], "valid"], [[93048, 93052], "disallowed"], [[93053, 93071], "valid"], [[93072, 93951], "disallowed"], [[93952, 94020], "valid"], [[94021, 94031], "disallowed"], [[94032, 94078], "valid"], [[94079, 94094], "disallowed"], [[94095, 94111], "valid"], [[94112, 110591], "disallowed"], [[110592, 110593], "valid"], [[110594, 113663], "disallowed"], [[113664, 113770], "valid"], [[113771, 113775], "disallowed"], [[113776, 113788], "valid"], [[113789, 113791], "disallowed"], [[113792, 113800], "valid"], [[113801, 113807], "disallowed"], [[113808, 113817], "valid"], [[113818, 113819], "disallowed"], [[113820, 113820], "valid", [], "NV8"], [[113821, 113822], "valid"], [[113823, 113823], "valid", [], "NV8"], [[113824, 113827], "ignored"], [[113828, 118783], "disallowed"], [[118784, 119029], "valid", [], "NV8"], [[119030, 119039], "disallowed"], [[119040, 119078], "valid", [], "NV8"], [[119079, 119080], "disallowed"], [[119081, 119081], "valid", [], "NV8"], [[119082, 119133], "valid", [], "NV8"], [[119134, 119134], "mapped", [119127, 119141]], [[119135, 119135], "mapped", [119128, 119141]], [[119136, 119136], "mapped", [119128, 119141, 119150]], [[119137, 119137], "mapped", [119128, 119141, 119151]], [[119138, 119138], "mapped", [119128, 119141, 119152]], [[119139, 119139], "mapped", [119128, 119141, 119153]], [[119140, 119140], "mapped", [119128, 119141, 119154]], [[119141, 119154], "valid", [], "NV8"], [[119155, 119162], "disallowed"], [[119163, 119226], "valid", [], "NV8"], [[119227, 119227], "mapped", [119225, 119141]], [[119228, 119228], "mapped", [119226, 119141]], [[119229, 119229], "mapped", [119225, 119141, 119150]], [[119230, 119230], "mapped", [119226, 119141, 119150]], [[119231, 119231], "mapped", [119225, 119141, 119151]], [[119232, 119232], "mapped", [119226, 119141, 119151]], [[119233, 119261], "valid", [], "NV8"], [[119262, 119272], "valid", [], "NV8"], [[119273, 119295], "disallowed"], [[119296, 119365], "valid", [], "NV8"], [[119366, 119551], "disallowed"], [[119552, 119638], "valid", [], "NV8"], [[119639, 119647], "disallowed"], [[119648, 119665], "valid", [], "NV8"], [[119666, 119807], "disallowed"], [[119808, 119808], "mapped", [97]], [[119809, 119809], "mapped", [98]], [[119810, 119810], "mapped", [99]], [[119811, 119811], "mapped", [100]], [[119812, 119812], "mapped", [101]], [[119813, 119813], "mapped", [102]], [[119814, 119814], "mapped", [103]], [[119815, 119815], "mapped", [104]], [[119816, 119816], "mapped", [105]], [[119817, 119817], "mapped", [106]], [[119818, 119818], "mapped", [107]], [[119819, 119819], "mapped", [108]], [[119820, 119820], "mapped", [109]], [[119821, 119821], "mapped", [110]], [[119822, 119822], "mapped", [111]], [[119823, 119823], "mapped", [112]], [[119824, 119824], "mapped", [113]], [[119825, 119825], "mapped", [114]], [[119826, 119826], "mapped", [115]], [[119827, 119827], "mapped", [116]], [[119828, 119828], "mapped", [117]], [[119829, 119829], "mapped", [118]], [[119830, 119830], "mapped", [119]], [[119831, 119831], "mapped", [120]], [[119832, 119832], "mapped", [121]], [[119833, 119833], "mapped", [122]], [[119834, 119834], "mapped", [97]], [[119835, 119835], "mapped", [98]], [[119836, 119836], "mapped", [99]], [[119837, 119837], "mapped", [100]], [[119838, 119838], "mapped", [101]], [[119839, 119839], "mapped", [102]], [[119840, 119840], "mapped", [103]], [[119841, 119841], "mapped", [104]], [[119842, 119842], "mapped", [105]], [[119843, 119843], "mapped", [106]], [[119844, 119844], "mapped", [107]], [[119845, 119845], "mapped", [108]], [[119846, 119846], "mapped", [109]], [[119847, 119847], "mapped", [110]], [[119848, 119848], "mapped", [111]], [[119849, 119849], "mapped", [112]], [[119850, 119850], "mapped", [113]], [[119851, 119851], "mapped", [114]], [[119852, 119852], "mapped", [115]], [[119853, 119853], "mapped", [116]], [[119854, 119854], "mapped", [117]], [[119855, 119855], "mapped", [118]], [[119856, 119856], "mapped", [119]], [[119857, 119857], "mapped", [120]], [[119858, 119858], "mapped", [121]], [[119859, 119859], "mapped", [122]], [[119860, 119860], "mapped", [97]], [[119861, 119861], "mapped", [98]], [[119862, 119862], "mapped", [99]], [[119863, 119863], "mapped", [100]], [[119864, 119864], "mapped", [101]], [[119865, 119865], "mapped", [102]], [[119866, 119866], "mapped", [103]], [[119867, 119867], "mapped", [104]], [[119868, 119868], "mapped", [105]], [[119869, 119869], "mapped", [106]], [[119870, 119870], "mapped", [107]], [[119871, 119871], "mapped", [108]], [[119872, 119872], "mapped", [109]], [[119873, 119873], "mapped", [110]], [[119874, 119874], "mapped", [111]], [[119875, 119875], "mapped", [112]], [[119876, 119876], "mapped", [113]], [[119877, 119877], "mapped", [114]], [[119878, 119878], "mapped", [115]], [[119879, 119879], "mapped", [116]], [[119880, 119880], "mapped", [117]], [[119881, 119881], "mapped", [118]], [[119882, 119882], "mapped", [119]], [[119883, 119883], "mapped", [120]], [[119884, 119884], "mapped", [121]], [[119885, 119885], "mapped", [122]], [[119886, 119886], "mapped", [97]], [[119887, 119887], "mapped", [98]], [[119888, 119888], "mapped", [99]], [[119889, 119889], "mapped", [100]], [[119890, 119890], "mapped", [101]], [[119891, 119891], "mapped", [102]], [[119892, 119892], "mapped", [103]], [[119893, 119893], "disallowed"], [[119894, 119894], "mapped", [105]], [[119895, 119895], "mapped", [106]], [[119896, 119896], "mapped", [107]], [[119897, 119897], "mapped", [108]], [[119898, 119898], "mapped", [109]], [[119899, 119899], "mapped", [110]], [[119900, 119900], "mapped", [111]], [[119901, 119901], "mapped", [112]], [[119902, 119902], "mapped", [113]], [[119903, 119903], "mapped", [114]], [[119904, 119904], "mapped", [115]], [[119905, 119905], "mapped", [116]], [[119906, 119906], "mapped", [117]], [[119907, 119907], "mapped", [118]], [[119908, 119908], "mapped", [119]], [[119909, 119909], "mapped", [120]], [[119910, 119910], "mapped", [121]], [[119911, 119911], "mapped", [122]], [[119912, 119912], "mapped", [97]], [[119913, 119913], "mapped", [98]], [[119914, 119914], "mapped", [99]], [[119915, 119915], "mapped", [100]], [[119916, 119916], "mapped", [101]], [[119917, 119917], "mapped", [102]], [[119918, 119918], "mapped", [103]], [[119919, 119919], "mapped", [104]], [[119920, 119920], "mapped", [105]], [[119921, 119921], "mapped", [106]], [[119922, 119922], "mapped", [107]], [[119923, 119923], "mapped", [108]], [[119924, 119924], "mapped", [109]], [[119925, 119925], "mapped", [110]], [[119926, 119926], "mapped", [111]], [[119927, 119927], "mapped", [112]], [[119928, 119928], "mapped", [113]], [[119929, 119929], "mapped", [114]], [[119930, 119930], "mapped", [115]], [[119931, 119931], "mapped", [116]], [[119932, 119932], "mapped", [117]], [[119933, 119933], "mapped", [118]], [[119934, 119934], "mapped", [119]], [[119935, 119935], "mapped", [120]], [[119936, 119936], "mapped", [121]], [[119937, 119937], "mapped", [122]], [[119938, 119938], "mapped", [97]], [[119939, 119939], "mapped", [98]], [[119940, 119940], "mapped", [99]], [[119941, 119941], "mapped", [100]], [[119942, 119942], "mapped", [101]], [[119943, 119943], "mapped", [102]], [[119944, 119944], "mapped", [103]], [[119945, 119945], "mapped", [104]], [[119946, 119946], "mapped", [105]], [[119947, 119947], "mapped", [106]], [[119948, 119948], "mapped", [107]], [[119949, 119949], "mapped", [108]], [[119950, 119950], "mapped", [109]], [[119951, 119951], "mapped", [110]], [[119952, 119952], "mapped", [111]], [[119953, 119953], "mapped", [112]], [[119954, 119954], "mapped", [113]], [[119955, 119955], "mapped", [114]], [[119956, 119956], "mapped", [115]], [[119957, 119957], "mapped", [116]], [[119958, 119958], "mapped", [117]], [[119959, 119959], "mapped", [118]], [[119960, 119960], "mapped", [119]], [[119961, 119961], "mapped", [120]], [[119962, 119962], "mapped", [121]], [[119963, 119963], "mapped", [122]], [[119964, 119964], "mapped", [97]], [[119965, 119965], "disallowed"], [[119966, 119966], "mapped", [99]], [[119967, 119967], "mapped", [100]], [[119968, 119969], "disallowed"], [[119970, 119970], "mapped", [103]], [[119971, 119972], "disallowed"], [[119973, 119973], "mapped", [106]], [[119974, 119974], "mapped", [107]], [[119975, 119976], "disallowed"], [[119977, 119977], "mapped", [110]], [[119978, 119978], "mapped", [111]], [[119979, 119979], "mapped", [112]], [[119980, 119980], "mapped", [113]], [[119981, 119981], "disallowed"], [[119982, 119982], "mapped", [115]], [[119983, 119983], "mapped", [116]], [[119984, 119984], "mapped", [117]], [[119985, 119985], "mapped", [118]], [[119986, 119986], "mapped", [119]], [[119987, 119987], "mapped", [120]], [[119988, 119988], "mapped", [121]], [[119989, 119989], "mapped", [122]], [[119990, 119990], "mapped", [97]], [[119991, 119991], "mapped", [98]], [[119992, 119992], "mapped", [99]], [[119993, 119993], "mapped", [100]], [[119994, 119994], "disallowed"], [[119995, 119995], "mapped", [102]], [[119996, 119996], "disallowed"], [[119997, 119997], "mapped", [104]], [[119998, 119998], "mapped", [105]], [[119999, 119999], "mapped", [106]], [[120000, 120000], "mapped", [107]], [[120001, 120001], "mapped", [108]], [[120002, 120002], "mapped", [109]], [[120003, 120003], "mapped", [110]], [[120004, 120004], "disallowed"], [[120005, 120005], "mapped", [112]], [[120006, 120006], "mapped", [113]], [[120007, 120007], "mapped", [114]], [[120008, 120008], "mapped", [115]], [[120009, 120009], "mapped", [116]], [[120010, 120010], "mapped", [117]], [[120011, 120011], "mapped", [118]], [[120012, 120012], "mapped", [119]], [[120013, 120013], "mapped", [120]], [[120014, 120014], "mapped", [121]], [[120015, 120015], "mapped", [122]], [[120016, 120016], "mapped", [97]], [[120017, 120017], "mapped", [98]], [[120018, 120018], "mapped", [99]], [[120019, 120019], "mapped", [100]], [[120020, 120020], "mapped", [101]], [[120021, 120021], "mapped", [102]], [[120022, 120022], "mapped", [103]], [[120023, 120023], "mapped", [104]], [[120024, 120024], "mapped", [105]], [[120025, 120025], "mapped", [106]], [[120026, 120026], "mapped", [107]], [[120027, 120027], "mapped", [108]], [[120028, 120028], "mapped", [109]], [[120029, 120029], "mapped", [110]], [[120030, 120030], "mapped", [111]], [[120031, 120031], "mapped", [112]], [[120032, 120032], "mapped", [113]], [[120033, 120033], "mapped", [114]], [[120034, 120034], "mapped", [115]], [[120035, 120035], "mapped", [116]], [[120036, 120036], "mapped", [117]], [[120037, 120037], "mapped", [118]], [[120038, 120038], "mapped", [119]], [[120039, 120039], "mapped", [120]], [[120040, 120040], "mapped", [121]], [[120041, 120041], "mapped", [122]], [[120042, 120042], "mapped", [97]], [[120043, 120043], "mapped", [98]], [[120044, 120044], "mapped", [99]], [[120045, 120045], "mapped", [100]], [[120046, 120046], "mapped", [101]], [[120047, 120047], "mapped", [102]], [[120048, 120048], "mapped", [103]], [[120049, 120049], "mapped", [104]], [[120050, 120050], "mapped", [105]], [[120051, 120051], "mapped", [106]], [[120052, 120052], "mapped", [107]], [[120053, 120053], "mapped", [108]], [[120054, 120054], "mapped", [109]], [[120055, 120055], "mapped", [110]], [[120056, 120056], "mapped", [111]], [[120057, 120057], "mapped", [112]], [[120058, 120058], "mapped", [113]], [[120059, 120059], "mapped", [114]], [[120060, 120060], "mapped", [115]], [[120061, 120061], "mapped", [116]], [[120062, 120062], "mapped", [117]], [[120063, 120063], "mapped", [118]], [[120064, 120064], "mapped", [119]], [[120065, 120065], "mapped", [120]], [[120066, 120066], "mapped", [121]], [[120067, 120067], "mapped", [122]], [[120068, 120068], "mapped", [97]], [[120069, 120069], "mapped", [98]], [[120070, 120070], "disallowed"], [[120071, 120071], "mapped", [100]], [[120072, 120072], "mapped", [101]], [[120073, 120073], "mapped", [102]], [[120074, 120074], "mapped", [103]], [[120075, 120076], "disallowed"], [[120077, 120077], "mapped", [106]], [[120078, 120078], "mapped", [107]], [[120079, 120079], "mapped", [108]], [[120080, 120080], "mapped", [109]], [[120081, 120081], "mapped", [110]], [[120082, 120082], "mapped", [111]], [[120083, 120083], "mapped", [112]], [[120084, 120084], "mapped", [113]], [[120085, 120085], "disallowed"], [[120086, 120086], "mapped", [115]], [[120087, 120087], "mapped", [116]], [[120088, 120088], "mapped", [117]], [[120089, 120089], "mapped", [118]], [[120090, 120090], "mapped", [119]], [[120091, 120091], "mapped", [120]], [[120092, 120092], "mapped", [121]], [[120093, 120093], "disallowed"], [[120094, 120094], "mapped", [97]], [[120095, 120095], "mapped", [98]], [[120096, 120096], "mapped", [99]], [[120097, 120097], "mapped", [100]], [[120098, 120098], "mapped", [101]], [[120099, 120099], "mapped", [102]], [[120100, 120100], "mapped", [103]], [[120101, 120101], "mapped", [104]], [[120102, 120102], "mapped", [105]], [[120103, 120103], "mapped", [106]], [[120104, 120104], "mapped", [107]], [[120105, 120105], "mapped", [108]], [[120106, 120106], "mapped", [109]], [[120107, 120107], "mapped", [110]], [[120108, 120108], "mapped", [111]], [[120109, 120109], "mapped", [112]], [[120110, 120110], "mapped", [113]], [[120111, 120111], "mapped", [114]], [[120112, 120112], "mapped", [115]], [[120113, 120113], "mapped", [116]], [[120114, 120114], "mapped", [117]], [[120115, 120115], "mapped", [118]], [[120116, 120116], "mapped", [119]], [[120117, 120117], "mapped", [120]], [[120118, 120118], "mapped", [121]], [[120119, 120119], "mapped", [122]], [[120120, 120120], "mapped", [97]], [[120121, 120121], "mapped", [98]], [[120122, 120122], "disallowed"], [[120123, 120123], "mapped", [100]], [[120124, 120124], "mapped", [101]], [[120125, 120125], "mapped", [102]], [[120126, 120126], "mapped", [103]], [[120127, 120127], "disallowed"], [[120128, 120128], "mapped", [105]], [[120129, 120129], "mapped", [106]], [[120130, 120130], "mapped", [107]], [[120131, 120131], "mapped", [108]], [[120132, 120132], "mapped", [109]], [[120133, 120133], "disallowed"], [[120134, 120134], "mapped", [111]], [[120135, 120137], "disallowed"], [[120138, 120138], "mapped", [115]], [[120139, 120139], "mapped", [116]], [[120140, 120140], "mapped", [117]], [[120141, 120141], "mapped", [118]], [[120142, 120142], "mapped", [119]], [[120143, 120143], "mapped", [120]], [[120144, 120144], "mapped", [121]], [[120145, 120145], "disallowed"], [[120146, 120146], "mapped", [97]], [[120147, 120147], "mapped", [98]], [[120148, 120148], "mapped", [99]], [[120149, 120149], "mapped", [100]], [[120150, 120150], "mapped", [101]], [[120151, 120151], "mapped", [102]], [[120152, 120152], "mapped", [103]], [[120153, 120153], "mapped", [104]], [[120154, 120154], "mapped", [105]], [[120155, 120155], "mapped", [106]], [[120156, 120156], "mapped", [107]], [[120157, 120157], "mapped", [108]], [[120158, 120158], "mapped", [109]], [[120159, 120159], "mapped", [110]], [[120160, 120160], "mapped", [111]], [[120161, 120161], "mapped", [112]], [[120162, 120162], "mapped", [113]], [[120163, 120163], "mapped", [114]], [[120164, 120164], "mapped", [115]], [[120165, 120165], "mapped", [116]], [[120166, 120166], "mapped", [117]], [[120167, 120167], "mapped", [118]], [[120168, 120168], "mapped", [119]], [[120169, 120169], "mapped", [120]], [[120170, 120170], "mapped", [121]], [[120171, 120171], "mapped", [122]], [[120172, 120172], "mapped", [97]], [[120173, 120173], "mapped", [98]], [[120174, 120174], "mapped", [99]], [[120175, 120175], "mapped", [100]], [[120176, 120176], "mapped", [101]], [[120177, 120177], "mapped", [102]], [[120178, 120178], "mapped", [103]], [[120179, 120179], "mapped", [104]], [[120180, 120180], "mapped", [105]], [[120181, 120181], "mapped", [106]], [[120182, 120182], "mapped", [107]], [[120183, 120183], "mapped", [108]], [[120184, 120184], "mapped", [109]], [[120185, 120185], "mapped", [110]], [[120186, 120186], "mapped", [111]], [[120187, 120187], "mapped", [112]], [[120188, 120188], "mapped", [113]], [[120189, 120189], "mapped", [114]], [[120190, 120190], "mapped", [115]], [[120191, 120191], "mapped", [116]], [[120192, 120192], "mapped", [117]], [[120193, 120193], "mapped", [118]], [[120194, 120194], "mapped", [119]], [[120195, 120195], "mapped", [120]], [[120196, 120196], "mapped", [121]], [[120197, 120197], "mapped", [122]], [[120198, 120198], "mapped", [97]], [[120199, 120199], "mapped", [98]], [[120200, 120200], "mapped", [99]], [[120201, 120201], "mapped", [100]], [[120202, 120202], "mapped", [101]], [[120203, 120203], "mapped", [102]], [[120204, 120204], "mapped", [103]], [[120205, 120205], "mapped", [104]], [[120206, 120206], "mapped", [105]], [[120207, 120207], "mapped", [106]], [[120208, 120208], "mapped", [107]], [[120209, 120209], "mapped", [108]], [[120210, 120210], "mapped", [109]], [[120211, 120211], "mapped", [110]], [[120212, 120212], "mapped", [111]], [[120213, 120213], "mapped", [112]], [[120214, 120214], "mapped", [113]], [[120215, 120215], "mapped", [114]], [[120216, 120216], "mapped", [115]], [[120217, 120217], "mapped", [116]], [[120218, 120218], "mapped", [117]], [[120219, 120219], "mapped", [118]], [[120220, 120220], "mapped", [119]], [[120221, 120221], "mapped", [120]], [[120222, 120222], "mapped", [121]], [[120223, 120223], "mapped", [122]], [[120224, 120224], "mapped", [97]], [[120225, 120225], "mapped", [98]], [[120226, 120226], "mapped", [99]], [[120227, 120227], "mapped", [100]], [[120228, 120228], "mapped", [101]], [[120229, 120229], "mapped", [102]], [[120230, 120230], "mapped", [103]], [[120231, 120231], "mapped", [104]], [[120232, 120232], "mapped", [105]], [[120233, 120233], "mapped", [106]], [[120234, 120234], "mapped", [107]], [[120235, 120235], "mapped", [108]], [[120236, 120236], "mapped", [109]], [[120237, 120237], "mapped", [110]], [[120238, 120238], "mapped", [111]], [[120239, 120239], "mapped", [112]], [[120240, 120240], "mapped", [113]], [[120241, 120241], "mapped", [114]], [[120242, 120242], "mapped", [115]], [[120243, 120243], "mapped", [116]], [[120244, 120244], "mapped", [117]], [[120245, 120245], "mapped", [118]], [[120246, 120246], "mapped", [119]], [[120247, 120247], "mapped", [120]], [[120248, 120248], "mapped", [121]], [[120249, 120249], "mapped", [122]], [[120250, 120250], "mapped", [97]], [[120251, 120251], "mapped", [98]], [[120252, 120252], "mapped", [99]], [[120253, 120253], "mapped", [100]], [[120254, 120254], "mapped", [101]], [[120255, 120255], "mapped", [102]], [[120256, 120256], "mapped", [103]], [[120257, 120257], "mapped", [104]], [[120258, 120258], "mapped", [105]], [[120259, 120259], "mapped", [106]], [[120260, 120260], "mapped", [107]], [[120261, 120261], "mapped", [108]], [[120262, 120262], "mapped", [109]], [[120263, 120263], "mapped", [110]], [[120264, 120264], "mapped", [111]], [[120265, 120265], "mapped", [112]], [[120266, 120266], "mapped", [113]], [[120267, 120267], "mapped", [114]], [[120268, 120268], "mapped", [115]], [[120269, 120269], "mapped", [116]], [[120270, 120270], "mapped", [117]], [[120271, 120271], "mapped", [118]], [[120272, 120272], "mapped", [119]], [[120273, 120273], "mapped", [120]], [[120274, 120274], "mapped", [121]], [[120275, 120275], "mapped", [122]], [[120276, 120276], "mapped", [97]], [[120277, 120277], "mapped", [98]], [[120278, 120278], "mapped", [99]], [[120279, 120279], "mapped", [100]], [[120280, 120280], "mapped", [101]], [[120281, 120281], "mapped", [102]], [[120282, 120282], "mapped", [103]], [[120283, 120283], "mapped", [104]], [[120284, 120284], "mapped", [105]], [[120285, 120285], "mapped", [106]], [[120286, 120286], "mapped", [107]], [[120287, 120287], "mapped", [108]], [[120288, 120288], "mapped", [109]], [[120289, 120289], "mapped", [110]], [[120290, 120290], "mapped", [111]], [[120291, 120291], "mapped", [112]], [[120292, 120292], "mapped", [113]], [[120293, 120293], "mapped", [114]], [[120294, 120294], "mapped", [115]], [[120295, 120295], "mapped", [116]], [[120296, 120296], "mapped", [117]], [[120297, 120297], "mapped", [118]], [[120298, 120298], "mapped", [119]], [[120299, 120299], "mapped", [120]], [[120300, 120300], "mapped", [121]], [[120301, 120301], "mapped", [122]], [[120302, 120302], "mapped", [97]], [[120303, 120303], "mapped", [98]], [[120304, 120304], "mapped", [99]], [[120305, 120305], "mapped", [100]], [[120306, 120306], "mapped", [101]], [[120307, 120307], "mapped", [102]], [[120308, 120308], "mapped", [103]], [[120309, 120309], "mapped", [104]], [[120310, 120310], "mapped", [105]], [[120311, 120311], "mapped", [106]], [[120312, 120312], "mapped", [107]], [[120313, 120313], "mapped", [108]], [[120314, 120314], "mapped", [109]], [[120315, 120315], "mapped", [110]], [[120316, 120316], "mapped", [111]], [[120317, 120317], "mapped", [112]], [[120318, 120318], "mapped", [113]], [[120319, 120319], "mapped", [114]], [[120320, 120320], "mapped", [115]], [[120321, 120321], "mapped", [116]], [[120322, 120322], "mapped", [117]], [[120323, 120323], "mapped", [118]], [[120324, 120324], "mapped", [119]], [[120325, 120325], "mapped", [120]], [[120326, 120326], "mapped", [121]], [[120327, 120327], "mapped", [122]], [[120328, 120328], "mapped", [97]], [[120329, 120329], "mapped", [98]], [[120330, 120330], "mapped", [99]], [[120331, 120331], "mapped", [100]], [[120332, 120332], "mapped", [101]], [[120333, 120333], "mapped", [102]], [[120334, 120334], "mapped", [103]], [[120335, 120335], "mapped", [104]], [[120336, 120336], "mapped", [105]], [[120337, 120337], "mapped", [106]], [[120338, 120338], "mapped", [107]], [[120339, 120339], "mapped", [108]], [[120340, 120340], "mapped", [109]], [[120341, 120341], "mapped", [110]], [[120342, 120342], "mapped", [111]], [[120343, 120343], "mapped", [112]], [[120344, 120344], "mapped", [113]], [[120345, 120345], "mapped", [114]], [[120346, 120346], "mapped", [115]], [[120347, 120347], "mapped", [116]], [[120348, 120348], "mapped", [117]], [[120349, 120349], "mapped", [118]], [[120350, 120350], "mapped", [119]], [[120351, 120351], "mapped", [120]], [[120352, 120352], "mapped", [121]], [[120353, 120353], "mapped", [122]], [[120354, 120354], "mapped", [97]], [[120355, 120355], "mapped", [98]], [[120356, 120356], "mapped", [99]], [[120357, 120357], "mapped", [100]], [[120358, 120358], "mapped", [101]], [[120359, 120359], "mapped", [102]], [[120360, 120360], "mapped", [103]], [[120361, 120361], "mapped", [104]], [[120362, 120362], "mapped", [105]], [[120363, 120363], "mapped", [106]], [[120364, 120364], "mapped", [107]], [[120365, 120365], "mapped", [108]], [[120366, 120366], "mapped", [109]], [[120367, 120367], "mapped", [110]], [[120368, 120368], "mapped", [111]], [[120369, 120369], "mapped", [112]], [[120370, 120370], "mapped", [113]], [[120371, 120371], "mapped", [114]], [[120372, 120372], "mapped", [115]], [[120373, 120373], "mapped", [116]], [[120374, 120374], "mapped", [117]], [[120375, 120375], "mapped", [118]], [[120376, 120376], "mapped", [119]], [[120377, 120377], "mapped", [120]], [[120378, 120378], "mapped", [121]], [[120379, 120379], "mapped", [122]], [[120380, 120380], "mapped", [97]], [[120381, 120381], "mapped", [98]], [[120382, 120382], "mapped", [99]], [[120383, 120383], "mapped", [100]], [[120384, 120384], "mapped", [101]], [[120385, 120385], "mapped", [102]], [[120386, 120386], "mapped", [103]], [[120387, 120387], "mapped", [104]], [[120388, 120388], "mapped", [105]], [[120389, 120389], "mapped", [106]], [[120390, 120390], "mapped", [107]], [[120391, 120391], "mapped", [108]], [[120392, 120392], "mapped", [109]], [[120393, 120393], "mapped", [110]], [[120394, 120394], "mapped", [111]], [[120395, 120395], "mapped", [112]], [[120396, 120396], "mapped", [113]], [[120397, 120397], "mapped", [114]], [[120398, 120398], "mapped", [115]], [[120399, 120399], "mapped", [116]], [[120400, 120400], "mapped", [117]], [[120401, 120401], "mapped", [118]], [[120402, 120402], "mapped", [119]], [[120403, 120403], "mapped", [120]], [[120404, 120404], "mapped", [121]], [[120405, 120405], "mapped", [122]], [[120406, 120406], "mapped", [97]], [[120407, 120407], "mapped", [98]], [[120408, 120408], "mapped", [99]], [[120409, 120409], "mapped", [100]], [[120410, 120410], "mapped", [101]], [[120411, 120411], "mapped", [102]], [[120412, 120412], "mapped", [103]], [[120413, 120413], "mapped", [104]], [[120414, 120414], "mapped", [105]], [[120415, 120415], "mapped", [106]], [[120416, 120416], "mapped", [107]], [[120417, 120417], "mapped", [108]], [[120418, 120418], "mapped", [109]], [[120419, 120419], "mapped", [110]], [[120420, 120420], "mapped", [111]], [[120421, 120421], "mapped", [112]], [[120422, 120422], "mapped", [113]], [[120423, 120423], "mapped", [114]], [[120424, 120424], "mapped", [115]], [[120425, 120425], "mapped", [116]], [[120426, 120426], "mapped", [117]], [[120427, 120427], "mapped", [118]], [[120428, 120428], "mapped", [119]], [[120429, 120429], "mapped", [120]], [[120430, 120430], "mapped", [121]], [[120431, 120431], "mapped", [122]], [[120432, 120432], "mapped", [97]], [[120433, 120433], "mapped", [98]], [[120434, 120434], "mapped", [99]], [[120435, 120435], "mapped", [100]], [[120436, 120436], "mapped", [101]], [[120437, 120437], "mapped", [102]], [[120438, 120438], "mapped", [103]], [[120439, 120439], "mapped", [104]], [[120440, 120440], "mapped", [105]], [[120441, 120441], "mapped", [106]], [[120442, 120442], "mapped", [107]], [[120443, 120443], "mapped", [108]], [[120444, 120444], "mapped", [109]], [[120445, 120445], "mapped", [110]], [[120446, 120446], "mapped", [111]], [[120447, 120447], "mapped", [112]], [[120448, 120448], "mapped", [113]], [[120449, 120449], "mapped", [114]], [[120450, 120450], "mapped", [115]], [[120451, 120451], "mapped", [116]], [[120452, 120452], "mapped", [117]], [[120453, 120453], "mapped", [118]], [[120454, 120454], "mapped", [119]], [[120455, 120455], "mapped", [120]], [[120456, 120456], "mapped", [121]], [[120457, 120457], "mapped", [122]], [[120458, 120458], "mapped", [97]], [[120459, 120459], "mapped", [98]], [[120460, 120460], "mapped", [99]], [[120461, 120461], "mapped", [100]], [[120462, 120462], "mapped", [101]], [[120463, 120463], "mapped", [102]], [[120464, 120464], "mapped", [103]], [[120465, 120465], "mapped", [104]], [[120466, 120466], "mapped", [105]], [[120467, 120467], "mapped", [106]], [[120468, 120468], "mapped", [107]], [[120469, 120469], "mapped", [108]], [[120470, 120470], "mapped", [109]], [[120471, 120471], "mapped", [110]], [[120472, 120472], "mapped", [111]], [[120473, 120473], "mapped", [112]], [[120474, 120474], "mapped", [113]], [[120475, 120475], "mapped", [114]], [[120476, 120476], "mapped", [115]], [[120477, 120477], "mapped", [116]], [[120478, 120478], "mapped", [117]], [[120479, 120479], "mapped", [118]], [[120480, 120480], "mapped", [119]], [[120481, 120481], "mapped", [120]], [[120482, 120482], "mapped", [121]], [[120483, 120483], "mapped", [122]], [[120484, 120484], "mapped", [305]], [[120485, 120485], "mapped", [567]], [[120486, 120487], "disallowed"], [[120488, 120488], "mapped", [945]], [[120489, 120489], "mapped", [946]], [[120490, 120490], "mapped", [947]], [[120491, 120491], "mapped", [948]], [[120492, 120492], "mapped", [949]], [[120493, 120493], "mapped", [950]], [[120494, 120494], "mapped", [951]], [[120495, 120495], "mapped", [952]], [[120496, 120496], "mapped", [953]], [[120497, 120497], "mapped", [954]], [[120498, 120498], "mapped", [955]], [[120499, 120499], "mapped", [956]], [[120500, 120500], "mapped", [957]], [[120501, 120501], "mapped", [958]], [[120502, 120502], "mapped", [959]], [[120503, 120503], "mapped", [960]], [[120504, 120504], "mapped", [961]], [[120505, 120505], "mapped", [952]], [[120506, 120506], "mapped", [963]], [[120507, 120507], "mapped", [964]], [[120508, 120508], "mapped", [965]], [[120509, 120509], "mapped", [966]], [[120510, 120510], "mapped", [967]], [[120511, 120511], "mapped", [968]], [[120512, 120512], "mapped", [969]], [[120513, 120513], "mapped", [8711]], [[120514, 120514], "mapped", [945]], [[120515, 120515], "mapped", [946]], [[120516, 120516], "mapped", [947]], [[120517, 120517], "mapped", [948]], [[120518, 120518], "mapped", [949]], [[120519, 120519], "mapped", [950]], [[120520, 120520], "mapped", [951]], [[120521, 120521], "mapped", [952]], [[120522, 120522], "mapped", [953]], [[120523, 120523], "mapped", [954]], [[120524, 120524], "mapped", [955]], [[120525, 120525], "mapped", [956]], [[120526, 120526], "mapped", [957]], [[120527, 120527], "mapped", [958]], [[120528, 120528], "mapped", [959]], [[120529, 120529], "mapped", [960]], [[120530, 120530], "mapped", [961]], [[120531, 120532], "mapped", [963]], [[120533, 120533], "mapped", [964]], [[120534, 120534], "mapped", [965]], [[120535, 120535], "mapped", [966]], [[120536, 120536], "mapped", [967]], [[120537, 120537], "mapped", [968]], [[120538, 120538], "mapped", [969]], [[120539, 120539], "mapped", [8706]], [[120540, 120540], "mapped", [949]], [[120541, 120541], "mapped", [952]], [[120542, 120542], "mapped", [954]], [[120543, 120543], "mapped", [966]], [[120544, 120544], "mapped", [961]], [[120545, 120545], "mapped", [960]], [[120546, 120546], "mapped", [945]], [[120547, 120547], "mapped", [946]], [[120548, 120548], "mapped", [947]], [[120549, 120549], "mapped", [948]], [[120550, 120550], "mapped", [949]], [[120551, 120551], "mapped", [950]], [[120552, 120552], "mapped", [951]], [[120553, 120553], "mapped", [952]], [[120554, 120554], "mapped", [953]], [[120555, 120555], "mapped", [954]], [[120556, 120556], "mapped", [955]], [[120557, 120557], "mapped", [956]], [[120558, 120558], "mapped", [957]], [[120559, 120559], "mapped", [958]], [[120560, 120560], "mapped", [959]], [[120561, 120561], "mapped", [960]], [[120562, 120562], "mapped", [961]], [[120563, 120563], "mapped", [952]], [[120564, 120564], "mapped", [963]], [[120565, 120565], "mapped", [964]], [[120566, 120566], "mapped", [965]], [[120567, 120567], "mapped", [966]], [[120568, 120568], "mapped", [967]], [[120569, 120569], "mapped", [968]], [[120570, 120570], "mapped", [969]], [[120571, 120571], "mapped", [8711]], [[120572, 120572], "mapped", [945]], [[120573, 120573], "mapped", [946]], [[120574, 120574], "mapped", [947]], [[120575, 120575], "mapped", [948]], [[120576, 120576], "mapped", [949]], [[120577, 120577], "mapped", [950]], [[120578, 120578], "mapped", [951]], [[120579, 120579], "mapped", [952]], [[120580, 120580], "mapped", [953]], [[120581, 120581], "mapped", [954]], [[120582, 120582], "mapped", [955]], [[120583, 120583], "mapped", [956]], [[120584, 120584], "mapped", [957]], [[120585, 120585], "mapped", [958]], [[120586, 120586], "mapped", [959]], [[120587, 120587], "mapped", [960]], [[120588, 120588], "mapped", [961]], [[120589, 120590], "mapped", [963]], [[120591, 120591], "mapped", [964]], [[120592, 120592], "mapped", [965]], [[120593, 120593], "mapped", [966]], [[120594, 120594], "mapped", [967]], [[120595, 120595], "mapped", [968]], [[120596, 120596], "mapped", [969]], [[120597, 120597], "mapped", [8706]], [[120598, 120598], "mapped", [949]], [[120599, 120599], "mapped", [952]], [[120600, 120600], "mapped", [954]], [[120601, 120601], "mapped", [966]], [[120602, 120602], "mapped", [961]], [[120603, 120603], "mapped", [960]], [[120604, 120604], "mapped", [945]], [[120605, 120605], "mapped", [946]], [[120606, 120606], "mapped", [947]], [[120607, 120607], "mapped", [948]], [[120608, 120608], "mapped", [949]], [[120609, 120609], "mapped", [950]], [[120610, 120610], "mapped", [951]], [[120611, 120611], "mapped", [952]], [[120612, 120612], "mapped", [953]], [[120613, 120613], "mapped", [954]], [[120614, 120614], "mapped", [955]], [[120615, 120615], "mapped", [956]], [[120616, 120616], "mapped", [957]], [[120617, 120617], "mapped", [958]], [[120618, 120618], "mapped", [959]], [[120619, 120619], "mapped", [960]], [[120620, 120620], "mapped", [961]], [[120621, 120621], "mapped", [952]], [[120622, 120622], "mapped", [963]], [[120623, 120623], "mapped", [964]], [[120624, 120624], "mapped", [965]], [[120625, 120625], "mapped", [966]], [[120626, 120626], "mapped", [967]], [[120627, 120627], "mapped", [968]], [[120628, 120628], "mapped", [969]], [[120629, 120629], "mapped", [8711]], [[120630, 120630], "mapped", [945]], [[120631, 120631], "mapped", [946]], [[120632, 120632], "mapped", [947]], [[120633, 120633], "mapped", [948]], [[120634, 120634], "mapped", [949]], [[120635, 120635], "mapped", [950]], [[120636, 120636], "mapped", [951]], [[120637, 120637], "mapped", [952]], [[120638, 120638], "mapped", [953]], [[120639, 120639], "mapped", [954]], [[120640, 120640], "mapped", [955]], [[120641, 120641], "mapped", [956]], [[120642, 120642], "mapped", [957]], [[120643, 120643], "mapped", [958]], [[120644, 120644], "mapped", [959]], [[120645, 120645], "mapped", [960]], [[120646, 120646], "mapped", [961]], [[120647, 120648], "mapped", [963]], [[120649, 120649], "mapped", [964]], [[120650, 120650], "mapped", [965]], [[120651, 120651], "mapped", [966]], [[120652, 120652], "mapped", [967]], [[120653, 120653], "mapped", [968]], [[120654, 120654], "mapped", [969]], [[120655, 120655], "mapped", [8706]], [[120656, 120656], "mapped", [949]], [[120657, 120657], "mapped", [952]], [[120658, 120658], "mapped", [954]], [[120659, 120659], "mapped", [966]], [[120660, 120660], "mapped", [961]], [[120661, 120661], "mapped", [960]], [[120662, 120662], "mapped", [945]], [[120663, 120663], "mapped", [946]], [[120664, 120664], "mapped", [947]], [[120665, 120665], "mapped", [948]], [[120666, 120666], "mapped", [949]], [[120667, 120667], "mapped", [950]], [[120668, 120668], "mapped", [951]], [[120669, 120669], "mapped", [952]], [[120670, 120670], "mapped", [953]], [[120671, 120671], "mapped", [954]], [[120672, 120672], "mapped", [955]], [[120673, 120673], "mapped", [956]], [[120674, 120674], "mapped", [957]], [[120675, 120675], "mapped", [958]], [[120676, 120676], "mapped", [959]], [[120677, 120677], "mapped", [960]], [[120678, 120678], "mapped", [961]], [[120679, 120679], "mapped", [952]], [[120680, 120680], "mapped", [963]], [[120681, 120681], "mapped", [964]], [[120682, 120682], "mapped", [965]], [[120683, 120683], "mapped", [966]], [[120684, 120684], "mapped", [967]], [[120685, 120685], "mapped", [968]], [[120686, 120686], "mapped", [969]], [[120687, 120687], "mapped", [8711]], [[120688, 120688], "mapped", [945]], [[120689, 120689], "mapped", [946]], [[120690, 120690], "mapped", [947]], [[120691, 120691], "mapped", [948]], [[120692, 120692], "mapped", [949]], [[120693, 120693], "mapped", [950]], [[120694, 120694], "mapped", [951]], [[120695, 120695], "mapped", [952]], [[120696, 120696], "mapped", [953]], [[120697, 120697], "mapped", [954]], [[120698, 120698], "mapped", [955]], [[120699, 120699], "mapped", [956]], [[120700, 120700], "mapped", [957]], [[120701, 120701], "mapped", [958]], [[120702, 120702], "mapped", [959]], [[120703, 120703], "mapped", [960]], [[120704, 120704], "mapped", [961]], [[120705, 120706], "mapped", [963]], [[120707, 120707], "mapped", [964]], [[120708, 120708], "mapped", [965]], [[120709, 120709], "mapped", [966]], [[120710, 120710], "mapped", [967]], [[120711, 120711], "mapped", [968]], [[120712, 120712], "mapped", [969]], [[120713, 120713], "mapped", [8706]], [[120714, 120714], "mapped", [949]], [[120715, 120715], "mapped", [952]], [[120716, 120716], "mapped", [954]], [[120717, 120717], "mapped", [966]], [[120718, 120718], "mapped", [961]], [[120719, 120719], "mapped", [960]], [[120720, 120720], "mapped", [945]], [[120721, 120721], "mapped", [946]], [[120722, 120722], "mapped", [947]], [[120723, 120723], "mapped", [948]], [[120724, 120724], "mapped", [949]], [[120725, 120725], "mapped", [950]], [[120726, 120726], "mapped", [951]], [[120727, 120727], "mapped", [952]], [[120728, 120728], "mapped", [953]], [[120729, 120729], "mapped", [954]], [[120730, 120730], "mapped", [955]], [[120731, 120731], "mapped", [956]], [[120732, 120732], "mapped", [957]], [[120733, 120733], "mapped", [958]], [[120734, 120734], "mapped", [959]], [[120735, 120735], "mapped", [960]], [[120736, 120736], "mapped", [961]], [[120737, 120737], "mapped", [952]], [[120738, 120738], "mapped", [963]], [[120739, 120739], "mapped", [964]], [[120740, 120740], "mapped", [965]], [[120741, 120741], "mapped", [966]], [[120742, 120742], "mapped", [967]], [[120743, 120743], "mapped", [968]], [[120744, 120744], "mapped", [969]], [[120745, 120745], "mapped", [8711]], [[120746, 120746], "mapped", [945]], [[120747, 120747], "mapped", [946]], [[120748, 120748], "mapped", [947]], [[120749, 120749], "mapped", [948]], [[120750, 120750], "mapped", [949]], [[120751, 120751], "mapped", [950]], [[120752, 120752], "mapped", [951]], [[120753, 120753], "mapped", [952]], [[120754, 120754], "mapped", [953]], [[120755, 120755], "mapped", [954]], [[120756, 120756], "mapped", [955]], [[120757, 120757], "mapped", [956]], [[120758, 120758], "mapped", [957]], [[120759, 120759], "mapped", [958]], [[120760, 120760], "mapped", [959]], [[120761, 120761], "mapped", [960]], [[120762, 120762], "mapped", [961]], [[120763, 120764], "mapped", [963]], [[120765, 120765], "mapped", [964]], [[120766, 120766], "mapped", [965]], [[120767, 120767], "mapped", [966]], [[120768, 120768], "mapped", [967]], [[120769, 120769], "mapped", [968]], [[120770, 120770], "mapped", [969]], [[120771, 120771], "mapped", [8706]], [[120772, 120772], "mapped", [949]], [[120773, 120773], "mapped", [952]], [[120774, 120774], "mapped", [954]], [[120775, 120775], "mapped", [966]], [[120776, 120776], "mapped", [961]], [[120777, 120777], "mapped", [960]], [[120778, 120779], "mapped", [989]], [[120780, 120781], "disallowed"], [[120782, 120782], "mapped", [48]], [[120783, 120783], "mapped", [49]], [[120784, 120784], "mapped", [50]], [[120785, 120785], "mapped", [51]], [[120786, 120786], "mapped", [52]], [[120787, 120787], "mapped", [53]], [[120788, 120788], "mapped", [54]], [[120789, 120789], "mapped", [55]], [[120790, 120790], "mapped", [56]], [[120791, 120791], "mapped", [57]], [[120792, 120792], "mapped", [48]], [[120793, 120793], "mapped", [49]], [[120794, 120794], "mapped", [50]], [[120795, 120795], "mapped", [51]], [[120796, 120796], "mapped", [52]], [[120797, 120797], "mapped", [53]], [[120798, 120798], "mapped", [54]], [[120799, 120799], "mapped", [55]], [[120800, 120800], "mapped", [56]], [[120801, 120801], "mapped", [57]], [[120802, 120802], "mapped", [48]], [[120803, 120803], "mapped", [49]], [[120804, 120804], "mapped", [50]], [[120805, 120805], "mapped", [51]], [[120806, 120806], "mapped", [52]], [[120807, 120807], "mapped", [53]], [[120808, 120808], "mapped", [54]], [[120809, 120809], "mapped", [55]], [[120810, 120810], "mapped", [56]], [[120811, 120811], "mapped", [57]], [[120812, 120812], "mapped", [48]], [[120813, 120813], "mapped", [49]], [[120814, 120814], "mapped", [50]], [[120815, 120815], "mapped", [51]], [[120816, 120816], "mapped", [52]], [[120817, 120817], "mapped", [53]], [[120818, 120818], "mapped", [54]], [[120819, 120819], "mapped", [55]], [[120820, 120820], "mapped", [56]], [[120821, 120821], "mapped", [57]], [[120822, 120822], "mapped", [48]], [[120823, 120823], "mapped", [49]], [[120824, 120824], "mapped", [50]], [[120825, 120825], "mapped", [51]], [[120826, 120826], "mapped", [52]], [[120827, 120827], "mapped", [53]], [[120828, 120828], "mapped", [54]], [[120829, 120829], "mapped", [55]], [[120830, 120830], "mapped", [56]], [[120831, 120831], "mapped", [57]], [[120832, 121343], "valid", [], "NV8"], [[121344, 121398], "valid"], [[121399, 121402], "valid", [], "NV8"], [[121403, 121452], "valid"], [[121453, 121460], "valid", [], "NV8"], [[121461, 121461], "valid"], [[121462, 121475], "valid", [], "NV8"], [[121476, 121476], "valid"], [[121477, 121483], "valid", [], "NV8"], [[121484, 121498], "disallowed"], [[121499, 121503], "valid"], [[121504, 121504], "disallowed"], [[121505, 121519], "valid"], [[121520, 124927], "disallowed"], [[124928, 125124], "valid"], [[125125, 125126], "disallowed"], [[125127, 125135], "valid", [], "NV8"], [[125136, 125142], "valid"], [[125143, 126463], "disallowed"], [[126464, 126464], "mapped", [1575]], [[126465, 126465], "mapped", [1576]], [[126466, 126466], "mapped", [1580]], [[126467, 126467], "mapped", [1583]], [[126468, 126468], "disallowed"], [[126469, 126469], "mapped", [1608]], [[126470, 126470], "mapped", [1586]], [[126471, 126471], "mapped", [1581]], [[126472, 126472], "mapped", [1591]], [[126473, 126473], "mapped", [1610]], [[126474, 126474], "mapped", [1603]], [[126475, 126475], "mapped", [1604]], [[126476, 126476], "mapped", [1605]], [[126477, 126477], "mapped", [1606]], [[126478, 126478], "mapped", [1587]], [[126479, 126479], "mapped", [1593]], [[126480, 126480], "mapped", [1601]], [[126481, 126481], "mapped", [1589]], [[126482, 126482], "mapped", [1602]], [[126483, 126483], "mapped", [1585]], [[126484, 126484], "mapped", [1588]], [[126485, 126485], "mapped", [1578]], [[126486, 126486], "mapped", [1579]], [[126487, 126487], "mapped", [1582]], [[126488, 126488], "mapped", [1584]], [[126489, 126489], "mapped", [1590]], [[126490, 126490], "mapped", [1592]], [[126491, 126491], "mapped", [1594]], [[126492, 126492], "mapped", [1646]], [[126493, 126493], "mapped", [1722]], [[126494, 126494], "mapped", [1697]], [[126495, 126495], "mapped", [1647]], [[126496, 126496], "disallowed"], [[126497, 126497], "mapped", [1576]], [[126498, 126498], "mapped", [1580]], [[126499, 126499], "disallowed"], [[126500, 126500], "mapped", [1607]], [[126501, 126502], "disallowed"], [[126503, 126503], "mapped", [1581]], [[126504, 126504], "disallowed"], [[126505, 126505], "mapped", [1610]], [[126506, 126506], "mapped", [1603]], [[126507, 126507], "mapped", [1604]], [[126508, 126508], "mapped", [1605]], [[126509, 126509], "mapped", [1606]], [[126510, 126510], "mapped", [1587]], [[126511, 126511], "mapped", [1593]], [[126512, 126512], "mapped", [1601]], [[126513, 126513], "mapped", [1589]], [[126514, 126514], "mapped", [1602]], [[126515, 126515], "disallowed"], [[126516, 126516], "mapped", [1588]], [[126517, 126517], "mapped", [1578]], [[126518, 126518], "mapped", [1579]], [[126519, 126519], "mapped", [1582]], [[126520, 126520], "disallowed"], [[126521, 126521], "mapped", [1590]], [[126522, 126522], "disallowed"], [[126523, 126523], "mapped", [1594]], [[126524, 126529], "disallowed"], [[126530, 126530], "mapped", [1580]], [[126531, 126534], "disallowed"], [[126535, 126535], "mapped", [1581]], [[126536, 126536], "disallowed"], [[126537, 126537], "mapped", [1610]], [[126538, 126538], "disallowed"], [[126539, 126539], "mapped", [1604]], [[126540, 126540], "disallowed"], [[126541, 126541], "mapped", [1606]], [[126542, 126542], "mapped", [1587]], [[126543, 126543], "mapped", [1593]], [[126544, 126544], "disallowed"], [[126545, 126545], "mapped", [1589]], [[126546, 126546], "mapped", [1602]], [[126547, 126547], "disallowed"], [[126548, 126548], "mapped", [1588]], [[126549, 126550], "disallowed"], [[126551, 126551], "mapped", [1582]], [[126552, 126552], "disallowed"], [[126553, 126553], "mapped", [1590]], [[126554, 126554], "disallowed"], [[126555, 126555], "mapped", [1594]], [[126556, 126556], "disallowed"], [[126557, 126557], "mapped", [1722]], [[126558, 126558], "disallowed"], [[126559, 126559], "mapped", [1647]], [[126560, 126560], "disallowed"], [[126561, 126561], "mapped", [1576]], [[126562, 126562], "mapped", [1580]], [[126563, 126563], "disallowed"], [[126564, 126564], "mapped", [1607]], [[126565, 126566], "disallowed"], [[126567, 126567], "mapped", [1581]], [[126568, 126568], "mapped", [1591]], [[126569, 126569], "mapped", [1610]], [[126570, 126570], "mapped", [1603]], [[126571, 126571], "disallowed"], [[126572, 126572], "mapped", [1605]], [[126573, 126573], "mapped", [1606]], [[126574, 126574], "mapped", [1587]], [[126575, 126575], "mapped", [1593]], [[126576, 126576], "mapped", [1601]], [[126577, 126577], "mapped", [1589]], [[126578, 126578], "mapped", [1602]], [[126579, 126579], "disallowed"], [[126580, 126580], "mapped", [1588]], [[126581, 126581], "mapped", [1578]], [[126582, 126582], "mapped", [1579]], [[126583, 126583], "mapped", [1582]], [[126584, 126584], "disallowed"], [[126585, 126585], "mapped", [1590]], [[126586, 126586], "mapped", [1592]], [[126587, 126587], "mapped", [1594]], [[126588, 126588], "mapped", [1646]], [[126589, 126589], "disallowed"], [[126590, 126590], "mapped", [1697]], [[126591, 126591], "disallowed"], [[126592, 126592], "mapped", [1575]], [[126593, 126593], "mapped", [1576]], [[126594, 126594], "mapped", [1580]], [[126595, 126595], "mapped", [1583]], [[126596, 126596], "mapped", [1607]], [[126597, 126597], "mapped", [1608]], [[126598, 126598], "mapped", [1586]], [[126599, 126599], "mapped", [1581]], [[126600, 126600], "mapped", [1591]], [[126601, 126601], "mapped", [1610]], [[126602, 126602], "disallowed"], [[126603, 126603], "mapped", [1604]], [[126604, 126604], "mapped", [1605]], [[126605, 126605], "mapped", [1606]], [[126606, 126606], "mapped", [1587]], [[126607, 126607], "mapped", [1593]], [[126608, 126608], "mapped", [1601]], [[126609, 126609], "mapped", [1589]], [[126610, 126610], "mapped", [1602]], [[126611, 126611], "mapped", [1585]], [[126612, 126612], "mapped", [1588]], [[126613, 126613], "mapped", [1578]], [[126614, 126614], "mapped", [1579]], [[126615, 126615], "mapped", [1582]], [[126616, 126616], "mapped", [1584]], [[126617, 126617], "mapped", [1590]], [[126618, 126618], "mapped", [1592]], [[126619, 126619], "mapped", [1594]], [[126620, 126624], "disallowed"], [[126625, 126625], "mapped", [1576]], [[126626, 126626], "mapped", [1580]], [[126627, 126627], "mapped", [1583]], [[126628, 126628], "disallowed"], [[126629, 126629], "mapped", [1608]], [[126630, 126630], "mapped", [1586]], [[126631, 126631], "mapped", [1581]], [[126632, 126632], "mapped", [1591]], [[126633, 126633], "mapped", [1610]], [[126634, 126634], "disallowed"], [[126635, 126635], "mapped", [1604]], [[126636, 126636], "mapped", [1605]], [[126637, 126637], "mapped", [1606]], [[126638, 126638], "mapped", [1587]], [[126639, 126639], "mapped", [1593]], [[126640, 126640], "mapped", [1601]], [[126641, 126641], "mapped", [1589]], [[126642, 126642], "mapped", [1602]], [[126643, 126643], "mapped", [1585]], [[126644, 126644], "mapped", [1588]], [[126645, 126645], "mapped", [1578]], [[126646, 126646], "mapped", [1579]], [[126647, 126647], "mapped", [1582]], [[126648, 126648], "mapped", [1584]], [[126649, 126649], "mapped", [1590]], [[126650, 126650], "mapped", [1592]], [[126651, 126651], "mapped", [1594]], [[126652, 126703], "disallowed"], [[126704, 126705], "valid", [], "NV8"], [[126706, 126975], "disallowed"], [[126976, 127019], "valid", [], "NV8"], [[127020, 127023], "disallowed"], [[127024, 127123], "valid", [], "NV8"], [[127124, 127135], "disallowed"], [[127136, 127150], "valid", [], "NV8"], [[127151, 127152], "disallowed"], [[127153, 127166], "valid", [], "NV8"], [[127167, 127167], "valid", [], "NV8"], [[127168, 127168], "disallowed"], [[127169, 127183], "valid", [], "NV8"], [[127184, 127184], "disallowed"], [[127185, 127199], "valid", [], "NV8"], [[127200, 127221], "valid", [], "NV8"], [[127222, 127231], "disallowed"], [[127232, 127232], "disallowed"], [[127233, 127233], "disallowed_STD3_mapped", [48, 44]], [[127234, 127234], "disallowed_STD3_mapped", [49, 44]], [[127235, 127235], "disallowed_STD3_mapped", [50, 44]], [[127236, 127236], "disallowed_STD3_mapped", [51, 44]], [[127237, 127237], "disallowed_STD3_mapped", [52, 44]], [[127238, 127238], "disallowed_STD3_mapped", [53, 44]], [[127239, 127239], "disallowed_STD3_mapped", [54, 44]], [[127240, 127240], "disallowed_STD3_mapped", [55, 44]], [[127241, 127241], "disallowed_STD3_mapped", [56, 44]], [[127242, 127242], "disallowed_STD3_mapped", [57, 44]], [[127243, 127244], "valid", [], "NV8"], [[127245, 127247], "disallowed"], [[127248, 127248], "disallowed_STD3_mapped", [40, 97, 41]], [[127249, 127249], "disallowed_STD3_mapped", [40, 98, 41]], [[127250, 127250], "disallowed_STD3_mapped", [40, 99, 41]], [[127251, 127251], "disallowed_STD3_mapped", [40, 100, 41]], [[127252, 127252], "disallowed_STD3_mapped", [40, 101, 41]], [[127253, 127253], "disallowed_STD3_mapped", [40, 102, 41]], [[127254, 127254], "disallowed_STD3_mapped", [40, 103, 41]], [[127255, 127255], "disallowed_STD3_mapped", [40, 104, 41]], [[127256, 127256], "disallowed_STD3_mapped", [40, 105, 41]], [[127257, 127257], "disallowed_STD3_mapped", [40, 106, 41]], [[127258, 127258], "disallowed_STD3_mapped", [40, 107, 41]], [[127259, 127259], "disallowed_STD3_mapped", [40, 108, 41]], [[127260, 127260], "disallowed_STD3_mapped", [40, 109, 41]], [[127261, 127261], "disallowed_STD3_mapped", [40, 110, 41]], [[127262, 127262], "disallowed_STD3_mapped", [40, 111, 41]], [[127263, 127263], "disallowed_STD3_mapped", [40, 112, 41]], [[127264, 127264], "disallowed_STD3_mapped", [40, 113, 41]], [[127265, 127265], "disallowed_STD3_mapped", [40, 114, 41]], [[127266, 127266], "disallowed_STD3_mapped", [40, 115, 41]], [[127267, 127267], "disallowed_STD3_mapped", [40, 116, 41]], [[127268, 127268], "disallowed_STD3_mapped", [40, 117, 41]], [[127269, 127269], "disallowed_STD3_mapped", [40, 118, 41]], [[127270, 127270], "disallowed_STD3_mapped", [40, 119, 41]], [[127271, 127271], "disallowed_STD3_mapped", [40, 120, 41]], [[127272, 127272], "disallowed_STD3_mapped", [40, 121, 41]], [[127273, 127273], "disallowed_STD3_mapped", [40, 122, 41]], [[127274, 127274], "mapped", [12308, 115, 12309]], [[127275, 127275], "mapped", [99]], [[127276, 127276], "mapped", [114]], [[127277, 127277], "mapped", [99, 100]], [[127278, 127278], "mapped", [119, 122]], [[127279, 127279], "disallowed"], [[127280, 127280], "mapped", [97]], [[127281, 127281], "mapped", [98]], [[127282, 127282], "mapped", [99]], [[127283, 127283], "mapped", [100]], [[127284, 127284], "mapped", [101]], [[127285, 127285], "mapped", [102]], [[127286, 127286], "mapped", [103]], [[127287, 127287], "mapped", [104]], [[127288, 127288], "mapped", [105]], [[127289, 127289], "mapped", [106]], [[127290, 127290], "mapped", [107]], [[127291, 127291], "mapped", [108]], [[127292, 127292], "mapped", [109]], [[127293, 127293], "mapped", [110]], [[127294, 127294], "mapped", [111]], [[127295, 127295], "mapped", [112]], [[127296, 127296], "mapped", [113]], [[127297, 127297], "mapped", [114]], [[127298, 127298], "mapped", [115]], [[127299, 127299], "mapped", [116]], [[127300, 127300], "mapped", [117]], [[127301, 127301], "mapped", [118]], [[127302, 127302], "mapped", [119]], [[127303, 127303], "mapped", [120]], [[127304, 127304], "mapped", [121]], [[127305, 127305], "mapped", [122]], [[127306, 127306], "mapped", [104, 118]], [[127307, 127307], "mapped", [109, 118]], [[127308, 127308], "mapped", [115, 100]], [[127309, 127309], "mapped", [115, 115]], [[127310, 127310], "mapped", [112, 112, 118]], [[127311, 127311], "mapped", [119, 99]], [[127312, 127318], "valid", [], "NV8"], [[127319, 127319], "valid", [], "NV8"], [[127320, 127326], "valid", [], "NV8"], [[127327, 127327], "valid", [], "NV8"], [[127328, 127337], "valid", [], "NV8"], [[127338, 127338], "mapped", [109, 99]], [[127339, 127339], "mapped", [109, 100]], [[127340, 127343], "disallowed"], [[127344, 127352], "valid", [], "NV8"], [[127353, 127353], "valid", [], "NV8"], [[127354, 127354], "valid", [], "NV8"], [[127355, 127356], "valid", [], "NV8"], [[127357, 127358], "valid", [], "NV8"], [[127359, 127359], "valid", [], "NV8"], [[127360, 127369], "valid", [], "NV8"], [[127370, 127373], "valid", [], "NV8"], [[127374, 127375], "valid", [], "NV8"], [[127376, 127376], "mapped", [100, 106]], [[127377, 127386], "valid", [], "NV8"], [[127387, 127461], "disallowed"], [[127462, 127487], "valid", [], "NV8"], [[127488, 127488], "mapped", [12411, 12363]], [[127489, 127489], "mapped", [12467, 12467]], [[127490, 127490], "mapped", [12469]], [[127491, 127503], "disallowed"], [[127504, 127504], "mapped", [25163]], [[127505, 127505], "mapped", [23383]], [[127506, 127506], "mapped", [21452]], [[127507, 127507], "mapped", [12487]], [[127508, 127508], "mapped", [20108]], [[127509, 127509], "mapped", [22810]], [[127510, 127510], "mapped", [35299]], [[127511, 127511], "mapped", [22825]], [[127512, 127512], "mapped", [20132]], [[127513, 127513], "mapped", [26144]], [[127514, 127514], "mapped", [28961]], [[127515, 127515], "mapped", [26009]], [[127516, 127516], "mapped", [21069]], [[127517, 127517], "mapped", [24460]], [[127518, 127518], "mapped", [20877]], [[127519, 127519], "mapped", [26032]], [[127520, 127520], "mapped", [21021]], [[127521, 127521], "mapped", [32066]], [[127522, 127522], "mapped", [29983]], [[127523, 127523], "mapped", [36009]], [[127524, 127524], "mapped", [22768]], [[127525, 127525], "mapped", [21561]], [[127526, 127526], "mapped", [28436]], [[127527, 127527], "mapped", [25237]], [[127528, 127528], "mapped", [25429]], [[127529, 127529], "mapped", [19968]], [[127530, 127530], "mapped", [19977]], [[127531, 127531], "mapped", [36938]], [[127532, 127532], "mapped", [24038]], [[127533, 127533], "mapped", [20013]], [[127534, 127534], "mapped", [21491]], [[127535, 127535], "mapped", [25351]], [[127536, 127536], "mapped", [36208]], [[127537, 127537], "mapped", [25171]], [[127538, 127538], "mapped", [31105]], [[127539, 127539], "mapped", [31354]], [[127540, 127540], "mapped", [21512]], [[127541, 127541], "mapped", [28288]], [[127542, 127542], "mapped", [26377]], [[127543, 127543], "mapped", [26376]], [[127544, 127544], "mapped", [30003]], [[127545, 127545], "mapped", [21106]], [[127546, 127546], "mapped", [21942]], [[127547, 127551], "disallowed"], [[127552, 127552], "mapped", [12308, 26412, 12309]], [[127553, 127553], "mapped", [12308, 19977, 12309]], [[127554, 127554], "mapped", [12308, 20108, 12309]], [[127555, 127555], "mapped", [12308, 23433, 12309]], [[127556, 127556], "mapped", [12308, 28857, 12309]], [[127557, 127557], "mapped", [12308, 25171, 12309]], [[127558, 127558], "mapped", [12308, 30423, 12309]], [[127559, 127559], "mapped", [12308, 21213, 12309]], [[127560, 127560], "mapped", [12308, 25943, 12309]], [[127561, 127567], "disallowed"], [[127568, 127568], "mapped", [24471]], [[127569, 127569], "mapped", [21487]], [[127570, 127743], "disallowed"], [[127744, 127776], "valid", [], "NV8"], [[127777, 127788], "valid", [], "NV8"], [[127789, 127791], "valid", [], "NV8"], [[127792, 127797], "valid", [], "NV8"], [[127798, 127798], "valid", [], "NV8"], [[127799, 127868], "valid", [], "NV8"], [[127869, 127869], "valid", [], "NV8"], [[127870, 127871], "valid", [], "NV8"], [[127872, 127891], "valid", [], "NV8"], [[127892, 127903], "valid", [], "NV8"], [[127904, 127940], "valid", [], "NV8"], [[127941, 127941], "valid", [], "NV8"], [[127942, 127946], "valid", [], "NV8"], [[127947, 127950], "valid", [], "NV8"], [[127951, 127955], "valid", [], "NV8"], [[127956, 127967], "valid", [], "NV8"], [[127968, 127984], "valid", [], "NV8"], [[127985, 127991], "valid", [], "NV8"], [[127992, 127999], "valid", [], "NV8"], [[128000, 128062], "valid", [], "NV8"], [[128063, 128063], "valid", [], "NV8"], [[128064, 128064], "valid", [], "NV8"], [[128065, 128065], "valid", [], "NV8"], [[128066, 128247], "valid", [], "NV8"], [[128248, 128248], "valid", [], "NV8"], [[128249, 128252], "valid", [], "NV8"], [[128253, 128254], "valid", [], "NV8"], [[128255, 128255], "valid", [], "NV8"], [[128256, 128317], "valid", [], "NV8"], [[128318, 128319], "valid", [], "NV8"], [[128320, 128323], "valid", [], "NV8"], [[128324, 128330], "valid", [], "NV8"], [[128331, 128335], "valid", [], "NV8"], [[128336, 128359], "valid", [], "NV8"], [[128360, 128377], "valid", [], "NV8"], [[128378, 128378], "disallowed"], [[128379, 128419], "valid", [], "NV8"], [[128420, 128420], "disallowed"], [[128421, 128506], "valid", [], "NV8"], [[128507, 128511], "valid", [], "NV8"], [[128512, 128512], "valid", [], "NV8"], [[128513, 128528], "valid", [], "NV8"], [[128529, 128529], "valid", [], "NV8"], [[128530, 128532], "valid", [], "NV8"], [[128533, 128533], "valid", [], "NV8"], [[128534, 128534], "valid", [], "NV8"], [[128535, 128535], "valid", [], "NV8"], [[128536, 128536], "valid", [], "NV8"], [[128537, 128537], "valid", [], "NV8"], [[128538, 128538], "valid", [], "NV8"], [[128539, 128539], "valid", [], "NV8"], [[128540, 128542], "valid", [], "NV8"], [[128543, 128543], "valid", [], "NV8"], [[128544, 128549], "valid", [], "NV8"], [[128550, 128551], "valid", [], "NV8"], [[128552, 128555], "valid", [], "NV8"], [[128556, 128556], "valid", [], "NV8"], [[128557, 128557], "valid", [], "NV8"], [[128558, 128559], "valid", [], "NV8"], [[128560, 128563], "valid", [], "NV8"], [[128564, 128564], "valid", [], "NV8"], [[128565, 128576], "valid", [], "NV8"], [[128577, 128578], "valid", [], "NV8"], [[128579, 128580], "valid", [], "NV8"], [[128581, 128591], "valid", [], "NV8"], [[128592, 128639], "valid", [], "NV8"], [[128640, 128709], "valid", [], "NV8"], [[128710, 128719], "valid", [], "NV8"], [[128720, 128720], "valid", [], "NV8"], [[128721, 128735], "disallowed"], [[128736, 128748], "valid", [], "NV8"], [[128749, 128751], "disallowed"], [[128752, 128755], "valid", [], "NV8"], [[128756, 128767], "disallowed"], [[128768, 128883], "valid", [], "NV8"], [[128884, 128895], "disallowed"], [[128896, 128980], "valid", [], "NV8"], [[128981, 129023], "disallowed"], [[129024, 129035], "valid", [], "NV8"], [[129036, 129039], "disallowed"], [[129040, 129095], "valid", [], "NV8"], [[129096, 129103], "disallowed"], [[129104, 129113], "valid", [], "NV8"], [[129114, 129119], "disallowed"], [[129120, 129159], "valid", [], "NV8"], [[129160, 129167], "disallowed"], [[129168, 129197], "valid", [], "NV8"], [[129198, 129295], "disallowed"], [[129296, 129304], "valid", [], "NV8"], [[129305, 129407], "disallowed"], [[129408, 129412], "valid", [], "NV8"], [[129413, 129471], "disallowed"], [[129472, 129472], "valid", [], "NV8"], [[129473, 131069], "disallowed"], [[131070, 131071], "disallowed"], [[131072, 173782], "valid"], [[173783, 173823], "disallowed"], [[173824, 177972], "valid"], [[177973, 177983], "disallowed"], [[177984, 178205], "valid"], [[178206, 178207], "disallowed"], [[178208, 183969], "valid"], [[183970, 194559], "disallowed"], [[194560, 194560], "mapped", [20029]], [[194561, 194561], "mapped", [20024]], [[194562, 194562], "mapped", [20033]], [[194563, 194563], "mapped", [131362]], [[194564, 194564], "mapped", [20320]], [[194565, 194565], "mapped", [20398]], [[194566, 194566], "mapped", [20411]], [[194567, 194567], "mapped", [20482]], [[194568, 194568], "mapped", [20602]], [[194569, 194569], "mapped", [20633]], [[194570, 194570], "mapped", [20711]], [[194571, 194571], "mapped", [20687]], [[194572, 194572], "mapped", [13470]], [[194573, 194573], "mapped", [132666]], [[194574, 194574], "mapped", [20813]], [[194575, 194575], "mapped", [20820]], [[194576, 194576], "mapped", [20836]], [[194577, 194577], "mapped", [20855]], [[194578, 194578], "mapped", [132380]], [[194579, 194579], "mapped", [13497]], [[194580, 194580], "mapped", [20839]], [[194581, 194581], "mapped", [20877]], [[194582, 194582], "mapped", [132427]], [[194583, 194583], "mapped", [20887]], [[194584, 194584], "mapped", [20900]], [[194585, 194585], "mapped", [20172]], [[194586, 194586], "mapped", [20908]], [[194587, 194587], "mapped", [20917]], [[194588, 194588], "mapped", [168415]], [[194589, 194589], "mapped", [20981]], [[194590, 194590], "mapped", [20995]], [[194591, 194591], "mapped", [13535]], [[194592, 194592], "mapped", [21051]], [[194593, 194593], "mapped", [21062]], [[194594, 194594], "mapped", [21106]], [[194595, 194595], "mapped", [21111]], [[194596, 194596], "mapped", [13589]], [[194597, 194597], "mapped", [21191]], [[194598, 194598], "mapped", [21193]], [[194599, 194599], "mapped", [21220]], [[194600, 194600], "mapped", [21242]], [[194601, 194601], "mapped", [21253]], [[194602, 194602], "mapped", [21254]], [[194603, 194603], "mapped", [21271]], [[194604, 194604], "mapped", [21321]], [[194605, 194605], "mapped", [21329]], [[194606, 194606], "mapped", [21338]], [[194607, 194607], "mapped", [21363]], [[194608, 194608], "mapped", [21373]], [[194609, 194611], "mapped", [21375]], [[194612, 194612], "mapped", [133676]], [[194613, 194613], "mapped", [28784]], [[194614, 194614], "mapped", [21450]], [[194615, 194615], "mapped", [21471]], [[194616, 194616], "mapped", [133987]], [[194617, 194617], "mapped", [21483]], [[194618, 194618], "mapped", [21489]], [[194619, 194619], "mapped", [21510]], [[194620, 194620], "mapped", [21662]], [[194621, 194621], "mapped", [21560]], [[194622, 194622], "mapped", [21576]], [[194623, 194623], "mapped", [21608]], [[194624, 194624], "mapped", [21666]], [[194625, 194625], "mapped", [21750]], [[194626, 194626], "mapped", [21776]], [[194627, 194627], "mapped", [21843]], [[194628, 194628], "mapped", [21859]], [[194629, 194630], "mapped", [21892]], [[194631, 194631], "mapped", [21913]], [[194632, 194632], "mapped", [21931]], [[194633, 194633], "mapped", [21939]], [[194634, 194634], "mapped", [21954]], [[194635, 194635], "mapped", [22294]], [[194636, 194636], "mapped", [22022]], [[194637, 194637], "mapped", [22295]], [[194638, 194638], "mapped", [22097]], [[194639, 194639], "mapped", [22132]], [[194640, 194640], "mapped", [20999]], [[194641, 194641], "mapped", [22766]], [[194642, 194642], "mapped", [22478]], [[194643, 194643], "mapped", [22516]], [[194644, 194644], "mapped", [22541]], [[194645, 194645], "mapped", [22411]], [[194646, 194646], "mapped", [22578]], [[194647, 194647], "mapped", [22577]], [[194648, 194648], "mapped", [22700]], [[194649, 194649], "mapped", [136420]], [[194650, 194650], "mapped", [22770]], [[194651, 194651], "mapped", [22775]], [[194652, 194652], "mapped", [22790]], [[194653, 194653], "mapped", [22810]], [[194654, 194654], "mapped", [22818]], [[194655, 194655], "mapped", [22882]], [[194656, 194656], "mapped", [136872]], [[194657, 194657], "mapped", [136938]], [[194658, 194658], "mapped", [23020]], [[194659, 194659], "mapped", [23067]], [[194660, 194660], "mapped", [23079]], [[194661, 194661], "mapped", [23000]], [[194662, 194662], "mapped", [23142]], [[194663, 194663], "mapped", [14062]], [[194664, 194664], "disallowed"], [[194665, 194665], "mapped", [23304]], [[194666, 194667], "mapped", [23358]], [[194668, 194668], "mapped", [137672]], [[194669, 194669], "mapped", [23491]], [[194670, 194670], "mapped", [23512]], [[194671, 194671], "mapped", [23527]], [[194672, 194672], "mapped", [23539]], [[194673, 194673], "mapped", [138008]], [[194674, 194674], "mapped", [23551]], [[194675, 194675], "mapped", [23558]], [[194676, 194676], "disallowed"], [[194677, 194677], "mapped", [23586]], [[194678, 194678], "mapped", [14209]], [[194679, 194679], "mapped", [23648]], [[194680, 194680], "mapped", [23662]], [[194681, 194681], "mapped", [23744]], [[194682, 194682], "mapped", [23693]], [[194683, 194683], "mapped", [138724]], [[194684, 194684], "mapped", [23875]], [[194685, 194685], "mapped", [138726]], [[194686, 194686], "mapped", [23918]], [[194687, 194687], "mapped", [23915]], [[194688, 194688], "mapped", [23932]], [[194689, 194689], "mapped", [24033]], [[194690, 194690], "mapped", [24034]], [[194691, 194691], "mapped", [14383]], [[194692, 194692], "mapped", [24061]], [[194693, 194693], "mapped", [24104]], [[194694, 194694], "mapped", [24125]], [[194695, 194695], "mapped", [24169]], [[194696, 194696], "mapped", [14434]], [[194697, 194697], "mapped", [139651]], [[194698, 194698], "mapped", [14460]], [[194699, 194699], "mapped", [24240]], [[194700, 194700], "mapped", [24243]], [[194701, 194701], "mapped", [24246]], [[194702, 194702], "mapped", [24266]], [[194703, 194703], "mapped", [172946]], [[194704, 194704], "mapped", [24318]], [[194705, 194706], "mapped", [140081]], [[194707, 194707], "mapped", [33281]], [[194708, 194709], "mapped", [24354]], [[194710, 194710], "mapped", [14535]], [[194711, 194711], "mapped", [144056]], [[194712, 194712], "mapped", [156122]], [[194713, 194713], "mapped", [24418]], [[194714, 194714], "mapped", [24427]], [[194715, 194715], "mapped", [14563]], [[194716, 194716], "mapped", [24474]], [[194717, 194717], "mapped", [24525]], [[194718, 194718], "mapped", [24535]], [[194719, 194719], "mapped", [24569]], [[194720, 194720], "mapped", [24705]], [[194721, 194721], "mapped", [14650]], [[194722, 194722], "mapped", [14620]], [[194723, 194723], "mapped", [24724]], [[194724, 194724], "mapped", [141012]], [[194725, 194725], "mapped", [24775]], [[194726, 194726], "mapped", [24904]], [[194727, 194727], "mapped", [24908]], [[194728, 194728], "mapped", [24910]], [[194729, 194729], "mapped", [24908]], [[194730, 194730], "mapped", [24954]], [[194731, 194731], "mapped", [24974]], [[194732, 194732], "mapped", [25010]], [[194733, 194733], "mapped", [24996]], [[194734, 194734], "mapped", [25007]], [[194735, 194735], "mapped", [25054]], [[194736, 194736], "mapped", [25074]], [[194737, 194737], "mapped", [25078]], [[194738, 194738], "mapped", [25104]], [[194739, 194739], "mapped", [25115]], [[194740, 194740], "mapped", [25181]], [[194741, 194741], "mapped", [25265]], [[194742, 194742], "mapped", [25300]], [[194743, 194743], "mapped", [25424]], [[194744, 194744], "mapped", [142092]], [[194745, 194745], "mapped", [25405]], [[194746, 194746], "mapped", [25340]], [[194747, 194747], "mapped", [25448]], [[194748, 194748], "mapped", [25475]], [[194749, 194749], "mapped", [25572]], [[194750, 194750], "mapped", [142321]], [[194751, 194751], "mapped", [25634]], [[194752, 194752], "mapped", [25541]], [[194753, 194753], "mapped", [25513]], [[194754, 194754], "mapped", [14894]], [[194755, 194755], "mapped", [25705]], [[194756, 194756], "mapped", [25726]], [[194757, 194757], "mapped", [25757]], [[194758, 194758], "mapped", [25719]], [[194759, 194759], "mapped", [14956]], [[194760, 194760], "mapped", [25935]], [[194761, 194761], "mapped", [25964]], [[194762, 194762], "mapped", [143370]], [[194763, 194763], "mapped", [26083]], [[194764, 194764], "mapped", [26360]], [[194765, 194765], "mapped", [26185]], [[194766, 194766], "mapped", [15129]], [[194767, 194767], "mapped", [26257]], [[194768, 194768], "mapped", [15112]], [[194769, 194769], "mapped", [15076]], [[194770, 194770], "mapped", [20882]], [[194771, 194771], "mapped", [20885]], [[194772, 194772], "mapped", [26368]], [[194773, 194773], "mapped", [26268]], [[194774, 194774], "mapped", [32941]], [[194775, 194775], "mapped", [17369]], [[194776, 194776], "mapped", [26391]], [[194777, 194777], "mapped", [26395]], [[194778, 194778], "mapped", [26401]], [[194779, 194779], "mapped", [26462]], [[194780, 194780], "mapped", [26451]], [[194781, 194781], "mapped", [144323]], [[194782, 194782], "mapped", [15177]], [[194783, 194783], "mapped", [26618]], [[194784, 194784], "mapped", [26501]], [[194785, 194785], "mapped", [26706]], [[194786, 194786], "mapped", [26757]], [[194787, 194787], "mapped", [144493]], [[194788, 194788], "mapped", [26766]], [[194789, 194789], "mapped", [26655]], [[194790, 194790], "mapped", [26900]], [[194791, 194791], "mapped", [15261]], [[194792, 194792], "mapped", [26946]], [[194793, 194793], "mapped", [27043]], [[194794, 194794], "mapped", [27114]], [[194795, 194795], "mapped", [27304]], [[194796, 194796], "mapped", [145059]], [[194797, 194797], "mapped", [27355]], [[194798, 194798], "mapped", [15384]], [[194799, 194799], "mapped", [27425]], [[194800, 194800], "mapped", [145575]], [[194801, 194801], "mapped", [27476]], [[194802, 194802], "mapped", [15438]], [[194803, 194803], "mapped", [27506]], [[194804, 194804], "mapped", [27551]], [[194805, 194805], "mapped", [27578]], [[194806, 194806], "mapped", [27579]], [[194807, 194807], "mapped", [146061]], [[194808, 194808], "mapped", [138507]], [[194809, 194809], "mapped", [146170]], [[194810, 194810], "mapped", [27726]], [[194811, 194811], "mapped", [146620]], [[194812, 194812], "mapped", [27839]], [[194813, 194813], "mapped", [27853]], [[194814, 194814], "mapped", [27751]], [[194815, 194815], "mapped", [27926]], [[194816, 194816], "mapped", [27966]], [[194817, 194817], "mapped", [28023]], [[194818, 194818], "mapped", [27969]], [[194819, 194819], "mapped", [28009]], [[194820, 194820], "mapped", [28024]], [[194821, 194821], "mapped", [28037]], [[194822, 194822], "mapped", [146718]], [[194823, 194823], "mapped", [27956]], [[194824, 194824], "mapped", [28207]], [[194825, 194825], "mapped", [28270]], [[194826, 194826], "mapped", [15667]], [[194827, 194827], "mapped", [28363]], [[194828, 194828], "mapped", [28359]], [[194829, 194829], "mapped", [147153]], [[194830, 194830], "mapped", [28153]], [[194831, 194831], "mapped", [28526]], [[194832, 194832], "mapped", [147294]], [[194833, 194833], "mapped", [147342]], [[194834, 194834], "mapped", [28614]], [[194835, 194835], "mapped", [28729]], [[194836, 194836], "mapped", [28702]], [[194837, 194837], "mapped", [28699]], [[194838, 194838], "mapped", [15766]], [[194839, 194839], "mapped", [28746]], [[194840, 194840], "mapped", [28797]], [[194841, 194841], "mapped", [28791]], [[194842, 194842], "mapped", [28845]], [[194843, 194843], "mapped", [132389]], [[194844, 194844], "mapped", [28997]], [[194845, 194845], "mapped", [148067]], [[194846, 194846], "mapped", [29084]], [[194847, 194847], "disallowed"], [[194848, 194848], "mapped", [29224]], [[194849, 194849], "mapped", [29237]], [[194850, 194850], "mapped", [29264]], [[194851, 194851], "mapped", [149000]], [[194852, 194852], "mapped", [29312]], [[194853, 194853], "mapped", [29333]], [[194854, 194854], "mapped", [149301]], [[194855, 194855], "mapped", [149524]], [[194856, 194856], "mapped", [29562]], [[194857, 194857], "mapped", [29579]], [[194858, 194858], "mapped", [16044]], [[194859, 194859], "mapped", [29605]], [[194860, 194861], "mapped", [16056]], [[194862, 194862], "mapped", [29767]], [[194863, 194863], "mapped", [29788]], [[194864, 194864], "mapped", [29809]], [[194865, 194865], "mapped", [29829]], [[194866, 194866], "mapped", [29898]], [[194867, 194867], "mapped", [16155]], [[194868, 194868], "mapped", [29988]], [[194869, 194869], "mapped", [150582]], [[194870, 194870], "mapped", [30014]], [[194871, 194871], "mapped", [150674]], [[194872, 194872], "mapped", [30064]], [[194873, 194873], "mapped", [139679]], [[194874, 194874], "mapped", [30224]], [[194875, 194875], "mapped", [151457]], [[194876, 194876], "mapped", [151480]], [[194877, 194877], "mapped", [151620]], [[194878, 194878], "mapped", [16380]], [[194879, 194879], "mapped", [16392]], [[194880, 194880], "mapped", [30452]], [[194881, 194881], "mapped", [151795]], [[194882, 194882], "mapped", [151794]], [[194883, 194883], "mapped", [151833]], [[194884, 194884], "mapped", [151859]], [[194885, 194885], "mapped", [30494]], [[194886, 194887], "mapped", [30495]], [[194888, 194888], "mapped", [30538]], [[194889, 194889], "mapped", [16441]], [[194890, 194890], "mapped", [30603]], [[194891, 194891], "mapped", [16454]], [[194892, 194892], "mapped", [16534]], [[194893, 194893], "mapped", [152605]], [[194894, 194894], "mapped", [30798]], [[194895, 194895], "mapped", [30860]], [[194896, 194896], "mapped", [30924]], [[194897, 194897], "mapped", [16611]], [[194898, 194898], "mapped", [153126]], [[194899, 194899], "mapped", [31062]], [[194900, 194900], "mapped", [153242]], [[194901, 194901], "mapped", [153285]], [[194902, 194902], "mapped", [31119]], [[194903, 194903], "mapped", [31211]], [[194904, 194904], "mapped", [16687]], [[194905, 194905], "mapped", [31296]], [[194906, 194906], "mapped", [31306]], [[194907, 194907], "mapped", [31311]], [[194908, 194908], "mapped", [153980]], [[194909, 194910], "mapped", [154279]], [[194911, 194911], "disallowed"], [[194912, 194912], "mapped", [16898]], [[194913, 194913], "mapped", [154539]], [[194914, 194914], "mapped", [31686]], [[194915, 194915], "mapped", [31689]], [[194916, 194916], "mapped", [16935]], [[194917, 194917], "mapped", [154752]], [[194918, 194918], "mapped", [31954]], [[194919, 194919], "mapped", [17056]], [[194920, 194920], "mapped", [31976]], [[194921, 194921], "mapped", [31971]], [[194922, 194922], "mapped", [32000]], [[194923, 194923], "mapped", [155526]], [[194924, 194924], "mapped", [32099]], [[194925, 194925], "mapped", [17153]], [[194926, 194926], "mapped", [32199]], [[194927, 194927], "mapped", [32258]], [[194928, 194928], "mapped", [32325]], [[194929, 194929], "mapped", [17204]], [[194930, 194930], "mapped", [156200]], [[194931, 194931], "mapped", [156231]], [[194932, 194932], "mapped", [17241]], [[194933, 194933], "mapped", [156377]], [[194934, 194934], "mapped", [32634]], [[194935, 194935], "mapped", [156478]], [[194936, 194936], "mapped", [32661]], [[194937, 194937], "mapped", [32762]], [[194938, 194938], "mapped", [32773]], [[194939, 194939], "mapped", [156890]], [[194940, 194940], "mapped", [156963]], [[194941, 194941], "mapped", [32864]], [[194942, 194942], "mapped", [157096]], [[194943, 194943], "mapped", [32880]], [[194944, 194944], "mapped", [144223]], [[194945, 194945], "mapped", [17365]], [[194946, 194946], "mapped", [32946]], [[194947, 194947], "mapped", [33027]], [[194948, 194948], "mapped", [17419]], [[194949, 194949], "mapped", [33086]], [[194950, 194950], "mapped", [23221]], [[194951, 194951], "mapped", [157607]], [[194952, 194952], "mapped", [157621]], [[194953, 194953], "mapped", [144275]], [[194954, 194954], "mapped", [144284]], [[194955, 194955], "mapped", [33281]], [[194956, 194956], "mapped", [33284]], [[194957, 194957], "mapped", [36766]], [[194958, 194958], "mapped", [17515]], [[194959, 194959], "mapped", [33425]], [[194960, 194960], "mapped", [33419]], [[194961, 194961], "mapped", [33437]], [[194962, 194962], "mapped", [21171]], [[194963, 194963], "mapped", [33457]], [[194964, 194964], "mapped", [33459]], [[194965, 194965], "mapped", [33469]], [[194966, 194966], "mapped", [33510]], [[194967, 194967], "mapped", [158524]], [[194968, 194968], "mapped", [33509]], [[194969, 194969], "mapped", [33565]], [[194970, 194970], "mapped", [33635]], [[194971, 194971], "mapped", [33709]], [[194972, 194972], "mapped", [33571]], [[194973, 194973], "mapped", [33725]], [[194974, 194974], "mapped", [33767]], [[194975, 194975], "mapped", [33879]], [[194976, 194976], "mapped", [33619]], [[194977, 194977], "mapped", [33738]], [[194978, 194978], "mapped", [33740]], [[194979, 194979], "mapped", [33756]], [[194980, 194980], "mapped", [158774]], [[194981, 194981], "mapped", [159083]], [[194982, 194982], "mapped", [158933]], [[194983, 194983], "mapped", [17707]], [[194984, 194984], "mapped", [34033]], [[194985, 194985], "mapped", [34035]], [[194986, 194986], "mapped", [34070]], [[194987, 194987], "mapped", [160714]], [[194988, 194988], "mapped", [34148]], [[194989, 194989], "mapped", [159532]], [[194990, 194990], "mapped", [17757]], [[194991, 194991], "mapped", [17761]], [[194992, 194992], "mapped", [159665]], [[194993, 194993], "mapped", [159954]], [[194994, 194994], "mapped", [17771]], [[194995, 194995], "mapped", [34384]], [[194996, 194996], "mapped", [34396]], [[194997, 194997], "mapped", [34407]], [[194998, 194998], "mapped", [34409]], [[194999, 194999], "mapped", [34473]], [[195000, 195000], "mapped", [34440]], [[195001, 195001], "mapped", [34574]], [[195002, 195002], "mapped", [34530]], [[195003, 195003], "mapped", [34681]], [[195004, 195004], "mapped", [34600]], [[195005, 195005], "mapped", [34667]], [[195006, 195006], "mapped", [34694]], [[195007, 195007], "disallowed"], [[195008, 195008], "mapped", [34785]], [[195009, 195009], "mapped", [34817]], [[195010, 195010], "mapped", [17913]], [[195011, 195011], "mapped", [34912]], [[195012, 195012], "mapped", [34915]], [[195013, 195013], "mapped", [161383]], [[195014, 195014], "mapped", [35031]], [[195015, 195015], "mapped", [35038]], [[195016, 195016], "mapped", [17973]], [[195017, 195017], "mapped", [35066]], [[195018, 195018], "mapped", [13499]], [[195019, 195019], "mapped", [161966]], [[195020, 195020], "mapped", [162150]], [[195021, 195021], "mapped", [18110]], [[195022, 195022], "mapped", [18119]], [[195023, 195023], "mapped", [35488]], [[195024, 195024], "mapped", [35565]], [[195025, 195025], "mapped", [35722]], [[195026, 195026], "mapped", [35925]], [[195027, 195027], "mapped", [162984]], [[195028, 195028], "mapped", [36011]], [[195029, 195029], "mapped", [36033]], [[195030, 195030], "mapped", [36123]], [[195031, 195031], "mapped", [36215]], [[195032, 195032], "mapped", [163631]], [[195033, 195033], "mapped", [133124]], [[195034, 195034], "mapped", [36299]], [[195035, 195035], "mapped", [36284]], [[195036, 195036], "mapped", [36336]], [[195037, 195037], "mapped", [133342]], [[195038, 195038], "mapped", [36564]], [[195039, 195039], "mapped", [36664]], [[195040, 195040], "mapped", [165330]], [[195041, 195041], "mapped", [165357]], [[195042, 195042], "mapped", [37012]], [[195043, 195043], "mapped", [37105]], [[195044, 195044], "mapped", [37137]], [[195045, 195045], "mapped", [165678]], [[195046, 195046], "mapped", [37147]], [[195047, 195047], "mapped", [37432]], [[195048, 195048], "mapped", [37591]], [[195049, 195049], "mapped", [37592]], [[195050, 195050], "mapped", [37500]], [[195051, 195051], "mapped", [37881]], [[195052, 195052], "mapped", [37909]], [[195053, 195053], "mapped", [166906]], [[195054, 195054], "mapped", [38283]], [[195055, 195055], "mapped", [18837]], [[195056, 195056], "mapped", [38327]], [[195057, 195057], "mapped", [167287]], [[195058, 195058], "mapped", [18918]], [[195059, 195059], "mapped", [38595]], [[195060, 195060], "mapped", [23986]], [[195061, 195061], "mapped", [38691]], [[195062, 195062], "mapped", [168261]], [[195063, 195063], "mapped", [168474]], [[195064, 195064], "mapped", [19054]], [[195065, 195065], "mapped", [19062]], [[195066, 195066], "mapped", [38880]], [[195067, 195067], "mapped", [168970]], [[195068, 195068], "mapped", [19122]], [[195069, 195069], "mapped", [169110]], [[195070, 195071], "mapped", [38923]], [[195072, 195072], "mapped", [38953]], [[195073, 195073], "mapped", [169398]], [[195074, 195074], "mapped", [39138]], [[195075, 195075], "mapped", [19251]], [[195076, 195076], "mapped", [39209]], [[195077, 195077], "mapped", [39335]], [[195078, 195078], "mapped", [39362]], [[195079, 195079], "mapped", [39422]], [[195080, 195080], "mapped", [19406]], [[195081, 195081], "mapped", [170800]], [[195082, 195082], "mapped", [39698]], [[195083, 195083], "mapped", [40000]], [[195084, 195084], "mapped", [40189]], [[195085, 195085], "mapped", [19662]], [[195086, 195086], "mapped", [19693]], [[195087, 195087], "mapped", [40295]], [[195088, 195088], "mapped", [172238]], [[195089, 195089], "mapped", [19704]], [[195090, 195090], "mapped", [172293]], [[195091, 195091], "mapped", [172558]], [[195092, 195092], "mapped", [172689]], [[195093, 195093], "mapped", [40635]], [[195094, 195094], "mapped", [19798]], [[195095, 195095], "mapped", [40697]], [[195096, 195096], "mapped", [40702]], [[195097, 195097], "mapped", [40709]], [[195098, 195098], "mapped", [40719]], [[195099, 195099], "mapped", [40726]], [[195100, 195100], "mapped", [40763]], [[195101, 195101], "mapped", [173568]], [[195102, 196605], "disallowed"], [[196606, 196607], "disallowed"], [[196608, 262141], "disallowed"], [[262142, 262143], "disallowed"], [[262144, 327677], "disallowed"], [[327678, 327679], "disallowed"], [[327680, 393213], "disallowed"], [[393214, 393215], "disallowed"], [[393216, 458749], "disallowed"], [[458750, 458751], "disallowed"], [[458752, 524285], "disallowed"], [[524286, 524287], "disallowed"], [[524288, 589821], "disallowed"], [[589822, 589823], "disallowed"], [[589824, 655357], "disallowed"], [[655358, 655359], "disallowed"], [[655360, 720893], "disallowed"], [[720894, 720895], "disallowed"], [[720896, 786429], "disallowed"], [[786430, 786431], "disallowed"], [[786432, 851965], "disallowed"], [[851966, 851967], "disallowed"], [[851968, 917501], "disallowed"], [[917502, 917503], "disallowed"], [[917504, 917504], "disallowed"], [[917505, 917505], "disallowed"], [[917506, 917535], "disallowed"], [[917536, 917631], "disallowed"], [[917632, 917759], "disallowed"], [[917760, 917999], "ignored"], [[918000, 983037], "disallowed"], [[983038, 983039], "disallowed"], [[983040, 1048573], "disallowed"], [[1048574, 1048575], "disallowed"], [[1048576, 1114109], "disallowed"], [[1114110, 1114111], "disallowed"]];
|
|
});
|
|
|
|
// node_modules/tr46/index.js
|
|
var require_tr46 = __commonJS((exports, module) => {
|
|
var normalize = function(str) {
|
|
return str.split("\0").map(function(s) {
|
|
return s.normalize("NFC");
|
|
}).join("\0");
|
|
};
|
|
var findStatus = function(val) {
|
|
var start = 0;
|
|
var end = mappingTable.length - 1;
|
|
while (start <= end) {
|
|
var mid = Math.floor((start + end) / 2);
|
|
var target = mappingTable[mid];
|
|
if (target[0][0] <= val && target[0][1] >= val)
|
|
return target;
|
|
else if (target[0][0] > val)
|
|
end = mid - 1;
|
|
else
|
|
start = mid + 1;
|
|
}
|
|
return null;
|
|
};
|
|
var countSymbols = function(string) {
|
|
return string.replace(regexAstralSymbols, "_").length;
|
|
};
|
|
var mapChars = function(domain_name, useSTD3, processing_option) {
|
|
var hasError = false;
|
|
var processed = "";
|
|
var len = countSymbols(domain_name);
|
|
for (var i = 0;i < len; ++i) {
|
|
var codePoint = domain_name.codePointAt(i);
|
|
var status = findStatus(codePoint);
|
|
switch (status[1]) {
|
|
case "disallowed":
|
|
hasError = true;
|
|
processed += String.fromCodePoint(codePoint);
|
|
break;
|
|
case "ignored":
|
|
break;
|
|
case "mapped":
|
|
processed += String.fromCodePoint.apply(String, status[2]);
|
|
break;
|
|
case "deviation":
|
|
if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL)
|
|
processed += String.fromCodePoint.apply(String, status[2]);
|
|
else
|
|
processed += String.fromCodePoint(codePoint);
|
|
break;
|
|
case "valid":
|
|
processed += String.fromCodePoint(codePoint);
|
|
break;
|
|
case "disallowed_STD3_mapped":
|
|
if (useSTD3) {
|
|
hasError = true;
|
|
processed += String.fromCodePoint(codePoint);
|
|
} else
|
|
processed += String.fromCodePoint.apply(String, status[2]);
|
|
break;
|
|
case "disallowed_STD3_valid":
|
|
if (useSTD3)
|
|
hasError = true;
|
|
processed += String.fromCodePoint(codePoint);
|
|
break;
|
|
}
|
|
}
|
|
return {
|
|
string: processed,
|
|
error: hasError
|
|
};
|
|
};
|
|
var validateLabel = function(label, processing_option) {
|
|
if (label.substr(0, 4) === "xn--") {
|
|
label = punycode.toUnicode(label);
|
|
processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL;
|
|
}
|
|
var error = false;
|
|
if (normalize(label) !== label || label[3] === "-" && label[4] === "-" || label[0] === "-" || label[label.length - 1] === "-" || label.indexOf(".") !== -1 || label.search(combiningMarksRegex) === 0)
|
|
error = true;
|
|
var len = countSymbols(label);
|
|
for (var i = 0;i < len; ++i) {
|
|
var status = findStatus(label.codePointAt(i));
|
|
if (processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid" || processing === PROCESSING_OPTIONS.NONTRANSITIONAL && status[1] !== "valid" && status[1] !== "deviation") {
|
|
error = true;
|
|
break;
|
|
}
|
|
}
|
|
return {
|
|
label,
|
|
error
|
|
};
|
|
};
|
|
var processing = function(domain_name, useSTD3, processing_option) {
|
|
var result = mapChars(domain_name, useSTD3, processing_option);
|
|
result.string = normalize(result.string);
|
|
var labels = result.string.split(".");
|
|
for (var i = 0;i < labels.length; ++i)
|
|
try {
|
|
var validation = validateLabel(labels[i]);
|
|
labels[i] = validation.label;
|
|
result.error = result.error || validation.error;
|
|
} catch (e) {
|
|
result.error = true;
|
|
}
|
|
return {
|
|
string: labels.join("."),
|
|
error: result.error
|
|
};
|
|
};
|
|
var punycode = __require("punycode");
|
|
var mappingTable = require_mappingTable();
|
|
var PROCESSING_OPTIONS = {
|
|
TRANSITIONAL: 0,
|
|
NONTRANSITIONAL: 1
|
|
};
|
|
var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
|
var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/;
|
|
exports.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) {
|
|
var result = processing(domain_name, useSTD3, processing_option);
|
|
var labels = result.string.split(".");
|
|
labels = labels.map(function(l) {
|
|
try {
|
|
return punycode.toASCII(l);
|
|
} catch (e) {
|
|
result.error = true;
|
|
return l;
|
|
}
|
|
});
|
|
if (verifyDnsLength) {
|
|
var total = labels.slice(0, labels.length - 1).join(".").length;
|
|
if (total.length > 253 || total.length === 0)
|
|
result.error = true;
|
|
for (var i = 0;i < labels.length; ++i)
|
|
if (labels.length > 63 || labels.length === 0) {
|
|
result.error = true;
|
|
break;
|
|
}
|
|
}
|
|
if (result.error)
|
|
return null;
|
|
return labels.join(".");
|
|
};
|
|
exports.toUnicode = function(domain_name, useSTD3) {
|
|
var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL);
|
|
return {
|
|
domain: result.string,
|
|
error: result.error
|
|
};
|
|
};
|
|
exports.PROCESSING_OPTIONS = PROCESSING_OPTIONS;
|
|
});
|
|
|
|
// node_modules/whatwg-url/lib/url-state-machine.js
|
|
var require_url_state_machine = __commonJS((exports, module) => {
|
|
var countSymbols = function(str) {
|
|
return punycode.ucs2.decode(str).length;
|
|
};
|
|
var at = function(input, idx) {
|
|
const c = input[idx];
|
|
return isNaN(c) ? undefined : String.fromCodePoint(c);
|
|
};
|
|
var isASCIIDigit = function(c) {
|
|
return c >= 48 && c <= 57;
|
|
};
|
|
var isASCIIAlpha = function(c) {
|
|
return c >= 65 && c <= 90 || c >= 97 && c <= 122;
|
|
};
|
|
var isASCIIAlphanumeric = function(c) {
|
|
return isASCIIAlpha(c) || isASCIIDigit(c);
|
|
};
|
|
var isASCIIHex = function(c) {
|
|
return isASCIIDigit(c) || c >= 65 && c <= 70 || c >= 97 && c <= 102;
|
|
};
|
|
var isSingleDot = function(buffer) {
|
|
return buffer === "." || buffer.toLowerCase() === "%2e";
|
|
};
|
|
var isDoubleDot = function(buffer) {
|
|
buffer = buffer.toLowerCase();
|
|
return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e";
|
|
};
|
|
var isWindowsDriveLetterCodePoints = function(cp1, cp2) {
|
|
return isASCIIAlpha(cp1) && (cp2 === 58 || cp2 === 124);
|
|
};
|
|
var isWindowsDriveLetterString = function(string) {
|
|
return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|");
|
|
};
|
|
var isNormalizedWindowsDriveLetterString = function(string) {
|
|
return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && string[1] === ":";
|
|
};
|
|
var containsForbiddenHostCodePoint = function(string) {
|
|
return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|%|\/|:|\?|@|\[|\\|\]/) !== -1;
|
|
};
|
|
var containsForbiddenHostCodePointExcludingPercent = function(string) {
|
|
return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|\?|@|\[|\\|\]/) !== -1;
|
|
};
|
|
var isSpecialScheme = function(scheme) {
|
|
return specialSchemes[scheme] !== undefined;
|
|
};
|
|
var isSpecial = function(url) {
|
|
return isSpecialScheme(url.scheme);
|
|
};
|
|
var defaultPort = function(scheme) {
|
|
return specialSchemes[scheme];
|
|
};
|
|
var percentEncode = function(c) {
|
|
let hex = c.toString(16).toUpperCase();
|
|
if (hex.length === 1)
|
|
hex = "0" + hex;
|
|
return "%" + hex;
|
|
};
|
|
var utf8PercentEncode = function(c) {
|
|
const buf = new Buffer(c);
|
|
let str = "";
|
|
for (let i = 0;i < buf.length; ++i)
|
|
str += percentEncode(buf[i]);
|
|
return str;
|
|
};
|
|
var utf8PercentDecode = function(str) {
|
|
const input = new Buffer(str);
|
|
const output = [];
|
|
for (let i = 0;i < input.length; ++i)
|
|
if (input[i] !== 37)
|
|
output.push(input[i]);
|
|
else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) {
|
|
output.push(parseInt(input.slice(i + 1, i + 3).toString(), 16));
|
|
i += 2;
|
|
} else
|
|
output.push(input[i]);
|
|
return new Buffer(output).toString();
|
|
};
|
|
var isC0ControlPercentEncode = function(c) {
|
|
return c <= 31 || c > 126;
|
|
};
|
|
var isPathPercentEncode = function(c) {
|
|
return isC0ControlPercentEncode(c) || extraPathPercentEncodeSet.has(c);
|
|
};
|
|
var isUserinfoPercentEncode = function(c) {
|
|
return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c);
|
|
};
|
|
var percentEncodeChar = function(c, encodeSetPredicate) {
|
|
const cStr = String.fromCodePoint(c);
|
|
if (encodeSetPredicate(c))
|
|
return utf8PercentEncode(cStr);
|
|
return cStr;
|
|
};
|
|
var parseIPv4Number = function(input) {
|
|
let R = 10;
|
|
if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") {
|
|
input = input.substring(2);
|
|
R = 16;
|
|
} else if (input.length >= 2 && input.charAt(0) === "0") {
|
|
input = input.substring(1);
|
|
R = 8;
|
|
}
|
|
if (input === "")
|
|
return 0;
|
|
const regex3 = R === 10 ? /[^0-9]/ : R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/;
|
|
if (regex3.test(input))
|
|
return failure;
|
|
return parseInt(input, R);
|
|
};
|
|
var parseIPv4 = function(input) {
|
|
const parts = input.split(".");
|
|
if (parts[parts.length - 1] === "") {
|
|
if (parts.length > 1)
|
|
parts.pop();
|
|
}
|
|
if (parts.length > 4)
|
|
return input;
|
|
const numbers = [];
|
|
for (const part of parts) {
|
|
if (part === "")
|
|
return input;
|
|
const n = parseIPv4Number(part);
|
|
if (n === failure)
|
|
return input;
|
|
numbers.push(n);
|
|
}
|
|
for (let i = 0;i < numbers.length - 1; ++i)
|
|
if (numbers[i] > 255)
|
|
return failure;
|
|
if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length))
|
|
return failure;
|
|
let ipv4 = numbers.pop();
|
|
let counter = 0;
|
|
for (const n of numbers) {
|
|
ipv4 += n * Math.pow(256, 3 - counter);
|
|
++counter;
|
|
}
|
|
return ipv4;
|
|
};
|
|
var serializeIPv4 = function(address) {
|
|
let output = "";
|
|
let n = address;
|
|
for (let i = 1;i <= 4; ++i) {
|
|
output = String(n % 256) + output;
|
|
if (i !== 4)
|
|
output = "." + output;
|
|
n = Math.floor(n / 256);
|
|
}
|
|
return output;
|
|
};
|
|
var parseIPv6 = function(input) {
|
|
const address = [0, 0, 0, 0, 0, 0, 0, 0];
|
|
let pieceIndex = 0;
|
|
let compress = null;
|
|
let pointer = 0;
|
|
input = punycode.ucs2.decode(input);
|
|
if (input[pointer] === 58) {
|
|
if (input[pointer + 1] !== 58)
|
|
return failure;
|
|
pointer += 2;
|
|
++pieceIndex;
|
|
compress = pieceIndex;
|
|
}
|
|
while (pointer < input.length) {
|
|
if (pieceIndex === 8)
|
|
return failure;
|
|
if (input[pointer] === 58) {
|
|
if (compress !== null)
|
|
return failure;
|
|
++pointer;
|
|
++pieceIndex;
|
|
compress = pieceIndex;
|
|
continue;
|
|
}
|
|
let value = 0;
|
|
let length = 0;
|
|
while (length < 4 && isASCIIHex(input[pointer])) {
|
|
value = value * 16 + parseInt(at(input, pointer), 16);
|
|
++pointer;
|
|
++length;
|
|
}
|
|
if (input[pointer] === 46) {
|
|
if (length === 0)
|
|
return failure;
|
|
pointer -= length;
|
|
if (pieceIndex > 6)
|
|
return failure;
|
|
let numbersSeen = 0;
|
|
while (input[pointer] !== undefined) {
|
|
let ipv4Piece = null;
|
|
if (numbersSeen > 0)
|
|
if (input[pointer] === 46 && numbersSeen < 4)
|
|
++pointer;
|
|
else
|
|
return failure;
|
|
if (!isASCIIDigit(input[pointer]))
|
|
return failure;
|
|
while (isASCIIDigit(input[pointer])) {
|
|
const number = parseInt(at(input, pointer));
|
|
if (ipv4Piece === null)
|
|
ipv4Piece = number;
|
|
else if (ipv4Piece === 0)
|
|
return failure;
|
|
else
|
|
ipv4Piece = ipv4Piece * 10 + number;
|
|
if (ipv4Piece > 255)
|
|
return failure;
|
|
++pointer;
|
|
}
|
|
address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
|
|
++numbersSeen;
|
|
if (numbersSeen === 2 || numbersSeen === 4)
|
|
++pieceIndex;
|
|
}
|
|
if (numbersSeen !== 4)
|
|
return failure;
|
|
break;
|
|
} else if (input[pointer] === 58) {
|
|
++pointer;
|
|
if (input[pointer] === undefined)
|
|
return failure;
|
|
} else if (input[pointer] !== undefined)
|
|
return failure;
|
|
address[pieceIndex] = value;
|
|
++pieceIndex;
|
|
}
|
|
if (compress !== null) {
|
|
let swaps = pieceIndex - compress;
|
|
pieceIndex = 7;
|
|
while (pieceIndex !== 0 && swaps > 0) {
|
|
const temp = address[compress + swaps - 1];
|
|
address[compress + swaps - 1] = address[pieceIndex];
|
|
address[pieceIndex] = temp;
|
|
--pieceIndex;
|
|
--swaps;
|
|
}
|
|
} else if (compress === null && pieceIndex !== 8)
|
|
return failure;
|
|
return address;
|
|
};
|
|
var serializeIPv6 = function(address) {
|
|
let output = "";
|
|
const seqResult = findLongestZeroSequence(address);
|
|
const compress = seqResult.idx;
|
|
let ignore0 = false;
|
|
for (let pieceIndex = 0;pieceIndex <= 7; ++pieceIndex) {
|
|
if (ignore0 && address[pieceIndex] === 0)
|
|
continue;
|
|
else if (ignore0)
|
|
ignore0 = false;
|
|
if (compress === pieceIndex) {
|
|
const separator = pieceIndex === 0 ? "::" : ":";
|
|
output += separator;
|
|
ignore0 = true;
|
|
continue;
|
|
}
|
|
output += address[pieceIndex].toString(16);
|
|
if (pieceIndex !== 7)
|
|
output += ":";
|
|
}
|
|
return output;
|
|
};
|
|
var parseHost = function(input, isSpecialArg) {
|
|
if (input[0] === "[") {
|
|
if (input[input.length - 1] !== "]")
|
|
return failure;
|
|
return parseIPv6(input.substring(1, input.length - 1));
|
|
}
|
|
if (!isSpecialArg)
|
|
return parseOpaqueHost(input);
|
|
const domain = utf8PercentDecode(input);
|
|
const asciiDomain = tr46.toASCII(domain, false, tr46.PROCESSING_OPTIONS.NONTRANSITIONAL, false);
|
|
if (asciiDomain === null)
|
|
return failure;
|
|
if (containsForbiddenHostCodePoint(asciiDomain))
|
|
return failure;
|
|
const ipv4Host = parseIPv4(asciiDomain);
|
|
if (typeof ipv4Host === "number" || ipv4Host === failure)
|
|
return ipv4Host;
|
|
return asciiDomain;
|
|
};
|
|
var parseOpaqueHost = function(input) {
|
|
if (containsForbiddenHostCodePointExcludingPercent(input))
|
|
return failure;
|
|
let output = "";
|
|
const decoded = punycode.ucs2.decode(input);
|
|
for (let i = 0;i < decoded.length; ++i)
|
|
output += percentEncodeChar(decoded[i], isC0ControlPercentEncode);
|
|
return output;
|
|
};
|
|
var findLongestZeroSequence = function(arr) {
|
|
let maxIdx = null;
|
|
let maxLen = 1;
|
|
let currStart = null;
|
|
let currLen = 0;
|
|
for (let i = 0;i < arr.length; ++i)
|
|
if (arr[i] !== 0) {
|
|
if (currLen > maxLen) {
|
|
maxIdx = currStart;
|
|
maxLen = currLen;
|
|
}
|
|
currStart = null;
|
|
currLen = 0;
|
|
} else {
|
|
if (currStart === null)
|
|
currStart = i;
|
|
++currLen;
|
|
}
|
|
if (currLen > maxLen) {
|
|
maxIdx = currStart;
|
|
maxLen = currLen;
|
|
}
|
|
return {
|
|
idx: maxIdx,
|
|
len: maxLen
|
|
};
|
|
};
|
|
var serializeHost = function(host) {
|
|
if (typeof host === "number")
|
|
return serializeIPv4(host);
|
|
if (host instanceof Array)
|
|
return "[" + serializeIPv6(host) + "]";
|
|
return host;
|
|
};
|
|
var trimControlChars = function(url) {
|
|
return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, "");
|
|
};
|
|
var trimTabAndNewline = function(url) {
|
|
return url.replace(/\u0009|\u000A|\u000D/g, "");
|
|
};
|
|
var shortenPath = function(url) {
|
|
const path = url.path;
|
|
if (path.length === 0)
|
|
return;
|
|
if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0]))
|
|
return;
|
|
path.pop();
|
|
};
|
|
var includesCredentials = function(url) {
|
|
return url.username !== "" || url.password !== "";
|
|
};
|
|
var cannotHaveAUsernamePasswordPort = function(url) {
|
|
return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file";
|
|
};
|
|
var isNormalizedWindowsDriveLetter = function(string) {
|
|
return /^[A-Za-z]:$/.test(string);
|
|
};
|
|
var URLStateMachine = function(input, base, encodingOverride, url, stateOverride) {
|
|
this.pointer = 0;
|
|
this.input = input;
|
|
this.base = base || null;
|
|
this.encodingOverride = encodingOverride || "utf-8";
|
|
this.stateOverride = stateOverride;
|
|
this.url = url;
|
|
this.failure = false;
|
|
this.parseError = false;
|
|
if (!this.url) {
|
|
this.url = {
|
|
scheme: "",
|
|
username: "",
|
|
password: "",
|
|
host: null,
|
|
port: null,
|
|
path: [],
|
|
query: null,
|
|
fragment: null,
|
|
cannotBeABaseURL: false
|
|
};
|
|
const res2 = trimControlChars(this.input);
|
|
if (res2 !== this.input)
|
|
this.parseError = true;
|
|
this.input = res2;
|
|
}
|
|
const res = trimTabAndNewline(this.input);
|
|
if (res !== this.input)
|
|
this.parseError = true;
|
|
this.input = res;
|
|
this.state = stateOverride || "scheme start";
|
|
this.buffer = "";
|
|
this.atFlag = false;
|
|
this.arrFlag = false;
|
|
this.passwordTokenSeenFlag = false;
|
|
this.input = punycode.ucs2.decode(this.input);
|
|
for (;this.pointer <= this.input.length; ++this.pointer) {
|
|
const c = this.input[this.pointer];
|
|
const cStr = isNaN(c) ? undefined : String.fromCodePoint(c);
|
|
const ret = this["parse " + this.state](c, cStr);
|
|
if (!ret)
|
|
break;
|
|
else if (ret === failure) {
|
|
this.failure = true;
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
var serializeURL = function(url, excludeFragment) {
|
|
let output = url.scheme + ":";
|
|
if (url.host !== null) {
|
|
output += "//";
|
|
if (url.username !== "" || url.password !== "") {
|
|
output += url.username;
|
|
if (url.password !== "")
|
|
output += ":" + url.password;
|
|
output += "@";
|
|
}
|
|
output += serializeHost(url.host);
|
|
if (url.port !== null)
|
|
output += ":" + url.port;
|
|
} else if (url.host === null && url.scheme === "file")
|
|
output += "//";
|
|
if (url.cannotBeABaseURL)
|
|
output += url.path[0];
|
|
else
|
|
for (const string of url.path)
|
|
output += "/" + string;
|
|
if (url.query !== null)
|
|
output += "?" + url.query;
|
|
if (!excludeFragment && url.fragment !== null)
|
|
output += "#" + url.fragment;
|
|
return output;
|
|
};
|
|
var serializeOrigin = function(tuple) {
|
|
let result = tuple.scheme + "://";
|
|
result += serializeHost(tuple.host);
|
|
if (tuple.port !== null)
|
|
result += ":" + tuple.port;
|
|
return result;
|
|
};
|
|
exports.parseURL = undefined;
|
|
var punycode = __require("punycode");
|
|
var tr46 = require_tr46();
|
|
var specialSchemes = {
|
|
ftp: 21,
|
|
file: null,
|
|
gopher: 70,
|
|
http: 80,
|
|
https: 443,
|
|
ws: 80,
|
|
wss: 443
|
|
};
|
|
var failure = Symbol("failure");
|
|
var extraPathPercentEncodeSet = new Set([32, 34, 35, 60, 62, 63, 96, 123, 125]);
|
|
var extraUserinfoPercentEncodeSet = new Set([47, 58, 59, 61, 64, 91, 92, 93, 94, 124]);
|
|
URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) {
|
|
if (isASCIIAlpha(c)) {
|
|
this.buffer += cStr.toLowerCase();
|
|
this.state = "scheme";
|
|
} else if (!this.stateOverride) {
|
|
this.state = "no scheme";
|
|
--this.pointer;
|
|
} else {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) {
|
|
if (isASCIIAlphanumeric(c) || c === 43 || c === 45 || c === 46)
|
|
this.buffer += cStr.toLowerCase();
|
|
else if (c === 58) {
|
|
if (this.stateOverride) {
|
|
if (isSpecial(this.url) && !isSpecialScheme(this.buffer))
|
|
return false;
|
|
if (!isSpecial(this.url) && isSpecialScheme(this.buffer))
|
|
return false;
|
|
if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file")
|
|
return false;
|
|
if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null))
|
|
return false;
|
|
}
|
|
this.url.scheme = this.buffer;
|
|
this.buffer = "";
|
|
if (this.stateOverride)
|
|
return false;
|
|
if (this.url.scheme === "file") {
|
|
if (this.input[this.pointer + 1] !== 47 || this.input[this.pointer + 2] !== 47)
|
|
this.parseError = true;
|
|
this.state = "file";
|
|
} else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme)
|
|
this.state = "special relative or authority";
|
|
else if (isSpecial(this.url))
|
|
this.state = "special authority slashes";
|
|
else if (this.input[this.pointer + 1] === 47) {
|
|
this.state = "path or authority";
|
|
++this.pointer;
|
|
} else {
|
|
this.url.cannotBeABaseURL = true;
|
|
this.url.path.push("");
|
|
this.state = "cannot-be-a-base-URL path";
|
|
}
|
|
} else if (!this.stateOverride) {
|
|
this.buffer = "";
|
|
this.state = "no scheme";
|
|
this.pointer = -1;
|
|
} else {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) {
|
|
if (this.base === null || this.base.cannotBeABaseURL && c !== 35)
|
|
return failure;
|
|
else if (this.base.cannotBeABaseURL && c === 35) {
|
|
this.url.scheme = this.base.scheme;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = this.base.query;
|
|
this.url.fragment = "";
|
|
this.url.cannotBeABaseURL = true;
|
|
this.state = "fragment";
|
|
} else if (this.base.scheme === "file") {
|
|
this.state = "file";
|
|
--this.pointer;
|
|
} else {
|
|
this.state = "relative";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) {
|
|
if (c === 47 && this.input[this.pointer + 1] === 47) {
|
|
this.state = "special authority ignore slashes";
|
|
++this.pointer;
|
|
} else {
|
|
this.parseError = true;
|
|
this.state = "relative";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) {
|
|
if (c === 47)
|
|
this.state = "authority";
|
|
else {
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse relative"] = function parseRelative(c) {
|
|
this.url.scheme = this.base.scheme;
|
|
if (isNaN(c)) {
|
|
this.url.username = this.base.username;
|
|
this.url.password = this.base.password;
|
|
this.url.host = this.base.host;
|
|
this.url.port = this.base.port;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = this.base.query;
|
|
} else if (c === 47)
|
|
this.state = "relative slash";
|
|
else if (c === 63) {
|
|
this.url.username = this.base.username;
|
|
this.url.password = this.base.password;
|
|
this.url.host = this.base.host;
|
|
this.url.port = this.base.port;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = "";
|
|
this.state = "query";
|
|
} else if (c === 35) {
|
|
this.url.username = this.base.username;
|
|
this.url.password = this.base.password;
|
|
this.url.host = this.base.host;
|
|
this.url.port = this.base.port;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = this.base.query;
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
} else if (isSpecial(this.url) && c === 92) {
|
|
this.parseError = true;
|
|
this.state = "relative slash";
|
|
} else {
|
|
this.url.username = this.base.username;
|
|
this.url.password = this.base.password;
|
|
this.url.host = this.base.host;
|
|
this.url.port = this.base.port;
|
|
this.url.path = this.base.path.slice(0, this.base.path.length - 1);
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) {
|
|
if (isSpecial(this.url) && (c === 47 || c === 92)) {
|
|
if (c === 92)
|
|
this.parseError = true;
|
|
this.state = "special authority ignore slashes";
|
|
} else if (c === 47)
|
|
this.state = "authority";
|
|
else {
|
|
this.url.username = this.base.username;
|
|
this.url.password = this.base.password;
|
|
this.url.host = this.base.host;
|
|
this.url.port = this.base.port;
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) {
|
|
if (c === 47 && this.input[this.pointer + 1] === 47) {
|
|
this.state = "special authority ignore slashes";
|
|
++this.pointer;
|
|
} else {
|
|
this.parseError = true;
|
|
this.state = "special authority ignore slashes";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) {
|
|
if (c !== 47 && c !== 92) {
|
|
this.state = "authority";
|
|
--this.pointer;
|
|
} else
|
|
this.parseError = true;
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) {
|
|
if (c === 64) {
|
|
this.parseError = true;
|
|
if (this.atFlag)
|
|
this.buffer = "%40" + this.buffer;
|
|
this.atFlag = true;
|
|
const len = countSymbols(this.buffer);
|
|
for (let pointer = 0;pointer < len; ++pointer) {
|
|
const codePoint = this.buffer.codePointAt(pointer);
|
|
if (codePoint === 58 && !this.passwordTokenSeenFlag) {
|
|
this.passwordTokenSeenFlag = true;
|
|
continue;
|
|
}
|
|
const encodedCodePoints = percentEncodeChar(codePoint, isUserinfoPercentEncode);
|
|
if (this.passwordTokenSeenFlag)
|
|
this.url.password += encodedCodePoints;
|
|
else
|
|
this.url.username += encodedCodePoints;
|
|
}
|
|
this.buffer = "";
|
|
} else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) {
|
|
if (this.atFlag && this.buffer === "") {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
this.pointer -= countSymbols(this.buffer) + 1;
|
|
this.buffer = "";
|
|
this.state = "host";
|
|
} else
|
|
this.buffer += cStr;
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse hostname"] = URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) {
|
|
if (this.stateOverride && this.url.scheme === "file") {
|
|
--this.pointer;
|
|
this.state = "file host";
|
|
} else if (c === 58 && !this.arrFlag) {
|
|
if (this.buffer === "") {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
const host = parseHost(this.buffer, isSpecial(this.url));
|
|
if (host === failure)
|
|
return failure;
|
|
this.url.host = host;
|
|
this.buffer = "";
|
|
this.state = "port";
|
|
if (this.stateOverride === "hostname")
|
|
return false;
|
|
} else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92) {
|
|
--this.pointer;
|
|
if (isSpecial(this.url) && this.buffer === "") {
|
|
this.parseError = true;
|
|
return failure;
|
|
} else if (this.stateOverride && this.buffer === "" && (includesCredentials(this.url) || this.url.port !== null)) {
|
|
this.parseError = true;
|
|
return false;
|
|
}
|
|
const host = parseHost(this.buffer, isSpecial(this.url));
|
|
if (host === failure)
|
|
return failure;
|
|
this.url.host = host;
|
|
this.buffer = "";
|
|
this.state = "path start";
|
|
if (this.stateOverride)
|
|
return false;
|
|
} else {
|
|
if (c === 91)
|
|
this.arrFlag = true;
|
|
else if (c === 93)
|
|
this.arrFlag = false;
|
|
this.buffer += cStr;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) {
|
|
if (isASCIIDigit(c))
|
|
this.buffer += cStr;
|
|
else if (isNaN(c) || c === 47 || c === 63 || c === 35 || isSpecial(this.url) && c === 92 || this.stateOverride) {
|
|
if (this.buffer !== "") {
|
|
const port = parseInt(this.buffer);
|
|
if (port > Math.pow(2, 16) - 1) {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
this.url.port = port === defaultPort(this.url.scheme) ? null : port;
|
|
this.buffer = "";
|
|
}
|
|
if (this.stateOverride)
|
|
return false;
|
|
this.state = "path start";
|
|
--this.pointer;
|
|
} else {
|
|
this.parseError = true;
|
|
return failure;
|
|
}
|
|
return true;
|
|
};
|
|
var fileOtherwiseCodePoints = new Set([47, 92, 63, 35]);
|
|
URLStateMachine.prototype["parse file"] = function parseFile(c) {
|
|
this.url.scheme = "file";
|
|
if (c === 47 || c === 92) {
|
|
if (c === 92)
|
|
this.parseError = true;
|
|
this.state = "file slash";
|
|
} else if (this.base !== null && this.base.scheme === "file")
|
|
if (isNaN(c)) {
|
|
this.url.host = this.base.host;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = this.base.query;
|
|
} else if (c === 63) {
|
|
this.url.host = this.base.host;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = "";
|
|
this.state = "query";
|
|
} else if (c === 35) {
|
|
this.url.host = this.base.host;
|
|
this.url.path = this.base.path.slice();
|
|
this.url.query = this.base.query;
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
} else {
|
|
if (this.input.length - this.pointer - 1 === 0 || !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) || this.input.length - this.pointer - 1 >= 2 && !fileOtherwiseCodePoints.has(this.input[this.pointer + 2])) {
|
|
this.url.host = this.base.host;
|
|
this.url.path = this.base.path.slice();
|
|
shortenPath(this.url);
|
|
} else
|
|
this.parseError = true;
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
else {
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) {
|
|
if (c === 47 || c === 92) {
|
|
if (c === 92)
|
|
this.parseError = true;
|
|
this.state = "file host";
|
|
} else {
|
|
if (this.base !== null && this.base.scheme === "file")
|
|
if (isNormalizedWindowsDriveLetterString(this.base.path[0]))
|
|
this.url.path.push(this.base.path[0]);
|
|
else
|
|
this.url.host = this.base.host;
|
|
this.state = "path";
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) {
|
|
if (isNaN(c) || c === 47 || c === 92 || c === 63 || c === 35) {
|
|
--this.pointer;
|
|
if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) {
|
|
this.parseError = true;
|
|
this.state = "path";
|
|
} else if (this.buffer === "") {
|
|
this.url.host = "";
|
|
if (this.stateOverride)
|
|
return false;
|
|
this.state = "path start";
|
|
} else {
|
|
let host = parseHost(this.buffer, isSpecial(this.url));
|
|
if (host === failure)
|
|
return failure;
|
|
if (host === "localhost")
|
|
host = "";
|
|
this.url.host = host;
|
|
if (this.stateOverride)
|
|
return false;
|
|
this.buffer = "";
|
|
this.state = "path start";
|
|
}
|
|
} else
|
|
this.buffer += cStr;
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse path start"] = function parsePathStart(c) {
|
|
if (isSpecial(this.url)) {
|
|
if (c === 92)
|
|
this.parseError = true;
|
|
this.state = "path";
|
|
if (c !== 47 && c !== 92)
|
|
--this.pointer;
|
|
} else if (!this.stateOverride && c === 63) {
|
|
this.url.query = "";
|
|
this.state = "query";
|
|
} else if (!this.stateOverride && c === 35) {
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
} else if (c !== undefined) {
|
|
this.state = "path";
|
|
if (c !== 47)
|
|
--this.pointer;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse path"] = function parsePath(c) {
|
|
if (isNaN(c) || c === 47 || isSpecial(this.url) && c === 92 || !this.stateOverride && (c === 63 || c === 35)) {
|
|
if (isSpecial(this.url) && c === 92)
|
|
this.parseError = true;
|
|
if (isDoubleDot(this.buffer)) {
|
|
shortenPath(this.url);
|
|
if (c !== 47 && !(isSpecial(this.url) && c === 92))
|
|
this.url.path.push("");
|
|
} else if (isSingleDot(this.buffer) && c !== 47 && !(isSpecial(this.url) && c === 92))
|
|
this.url.path.push("");
|
|
else if (!isSingleDot(this.buffer)) {
|
|
if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) {
|
|
if (this.url.host !== "" && this.url.host !== null) {
|
|
this.parseError = true;
|
|
this.url.host = "";
|
|
}
|
|
this.buffer = this.buffer[0] + ":";
|
|
}
|
|
this.url.path.push(this.buffer);
|
|
}
|
|
this.buffer = "";
|
|
if (this.url.scheme === "file" && (c === undefined || c === 63 || c === 35))
|
|
while (this.url.path.length > 1 && this.url.path[0] === "") {
|
|
this.parseError = true;
|
|
this.url.path.shift();
|
|
}
|
|
if (c === 63) {
|
|
this.url.query = "";
|
|
this.state = "query";
|
|
}
|
|
if (c === 35) {
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
}
|
|
} else {
|
|
if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2])))
|
|
this.parseError = true;
|
|
this.buffer += percentEncodeChar(c, isPathPercentEncode);
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse cannot-be-a-base-URL path"] = function parseCannotBeABaseURLPath(c) {
|
|
if (c === 63) {
|
|
this.url.query = "";
|
|
this.state = "query";
|
|
} else if (c === 35) {
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
} else {
|
|
if (!isNaN(c) && c !== 37)
|
|
this.parseError = true;
|
|
if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2])))
|
|
this.parseError = true;
|
|
if (!isNaN(c))
|
|
this.url.path[0] = this.url.path[0] + percentEncodeChar(c, isC0ControlPercentEncode);
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) {
|
|
if (isNaN(c) || !this.stateOverride && c === 35) {
|
|
if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss")
|
|
this.encodingOverride = "utf-8";
|
|
const buffer = new Buffer(this.buffer);
|
|
for (let i = 0;i < buffer.length; ++i)
|
|
if (buffer[i] < 33 || buffer[i] > 126 || buffer[i] === 34 || buffer[i] === 35 || buffer[i] === 60 || buffer[i] === 62)
|
|
this.url.query += percentEncode(buffer[i]);
|
|
else
|
|
this.url.query += String.fromCodePoint(buffer[i]);
|
|
this.buffer = "";
|
|
if (c === 35) {
|
|
this.url.fragment = "";
|
|
this.state = "fragment";
|
|
}
|
|
} else {
|
|
if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2])))
|
|
this.parseError = true;
|
|
this.buffer += cStr;
|
|
}
|
|
return true;
|
|
};
|
|
URLStateMachine.prototype["parse fragment"] = function parseFragment(c) {
|
|
if (isNaN(c))
|
|
;
|
|
else if (c === 0)
|
|
this.parseError = true;
|
|
else {
|
|
if (c === 37 && (!isASCIIHex(this.input[this.pointer + 1]) || !isASCIIHex(this.input[this.pointer + 2])))
|
|
this.parseError = true;
|
|
this.url.fragment += percentEncodeChar(c, isC0ControlPercentEncode);
|
|
}
|
|
return true;
|
|
};
|
|
exports.serializeURL = serializeURL;
|
|
exports.serializeURLOrigin = function(url) {
|
|
switch (url.scheme) {
|
|
case "blob":
|
|
try {
|
|
return exports.serializeURLOrigin(exports.parseURL(url.path[0]));
|
|
} catch (e) {
|
|
return "null";
|
|
}
|
|
case "ftp":
|
|
case "gopher":
|
|
case "http":
|
|
case "https":
|
|
case "ws":
|
|
case "wss":
|
|
return serializeOrigin({
|
|
scheme: url.scheme,
|
|
host: url.host,
|
|
port: url.port
|
|
});
|
|
case "file":
|
|
return "file://";
|
|
default:
|
|
return "null";
|
|
}
|
|
};
|
|
exports.basicURLParse = function(input, options) {
|
|
if (options === undefined)
|
|
options = {};
|
|
const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride);
|
|
if (usm.failure)
|
|
return "failure";
|
|
return usm.url;
|
|
};
|
|
exports.setTheUsername = function(url, username) {
|
|
url.username = "";
|
|
const decoded = punycode.ucs2.decode(username);
|
|
for (let i = 0;i < decoded.length; ++i)
|
|
url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
|
|
};
|
|
exports.setThePassword = function(url, password) {
|
|
url.password = "";
|
|
const decoded = punycode.ucs2.decode(password);
|
|
for (let i = 0;i < decoded.length; ++i)
|
|
url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
|
|
};
|
|
exports.serializeHost = serializeHost;
|
|
exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
|
|
exports.serializeInteger = function(integer) {
|
|
return String(integer);
|
|
};
|
|
exports.parseURL = function(input, options) {
|
|
if (options === undefined)
|
|
options = {};
|
|
return exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride });
|
|
};
|
|
});
|
|
|
|
// node_modules/whatwg-url/lib/URL-impl.js
|
|
var require_URL_impl = __commonJS((exports) => {
|
|
var usm = require_url_state_machine();
|
|
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;
|
|
}
|
|
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) {
|
|
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;
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/whatwg-url/lib/URL.js
|
|
var require_URL = __commonJS((exports, module) => {
|
|
var URL4 = function(url) {
|
|
if (!this || this[impl] || !(this instanceof URL4))
|
|
throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
|
|
if (arguments.length < 1)
|
|
throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
|
|
const args = [];
|
|
for (let i = 0;i < arguments.length && i < 2; ++i)
|
|
args[i] = arguments[i];
|
|
args[0] = conversions["USVString"](args[0]);
|
|
if (args[1] !== undefined)
|
|
args[1] = conversions["USVString"](args[1]);
|
|
exports.setup(this, args);
|
|
};
|
|
var conversions = require_lib3();
|
|
var utils = require_utils2();
|
|
var Impl = require_URL_impl();
|
|
var impl = utils.implSymbol;
|
|
URL4.prototype.toJSON = function toJSON() {
|
|
if (!this || !exports.is(this))
|
|
throw new TypeError("Illegal invocation");
|
|
const args = [];
|
|
for (let i = 0;i < arguments.length && i < 0; ++i)
|
|
args[i] = arguments[i];
|
|
return this[impl].toJSON.apply(this[impl], args);
|
|
};
|
|
Object.defineProperty(URL4.prototype, "href", {
|
|
get() {
|
|
return this[impl].href;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].href = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
URL4.prototype.toString = function() {
|
|
if (!this || !exports.is(this))
|
|
throw new TypeError("Illegal invocation");
|
|
return this.href;
|
|
};
|
|
Object.defineProperty(URL4.prototype, "origin", {
|
|
get() {
|
|
return this[impl].origin;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "protocol", {
|
|
get() {
|
|
return this[impl].protocol;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].protocol = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "username", {
|
|
get() {
|
|
return this[impl].username;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].username = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "password", {
|
|
get() {
|
|
return this[impl].password;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].password = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "host", {
|
|
get() {
|
|
return this[impl].host;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].host = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "hostname", {
|
|
get() {
|
|
return this[impl].hostname;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].hostname = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "port", {
|
|
get() {
|
|
return this[impl].port;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].port = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "pathname", {
|
|
get() {
|
|
return this[impl].pathname;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].pathname = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "search", {
|
|
get() {
|
|
return this[impl].search;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].search = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
Object.defineProperty(URL4.prototype, "hash", {
|
|
get() {
|
|
return this[impl].hash;
|
|
},
|
|
set(V) {
|
|
V = conversions["USVString"](V);
|
|
this[impl].hash = V;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
module.exports = {
|
|
is(obj) {
|
|
return !!obj && obj[impl] instanceof Impl.implementation;
|
|
},
|
|
create(constructorArgs, privateData) {
|
|
let obj = Object.create(URL4.prototype);
|
|
this.setup(obj, constructorArgs, privateData);
|
|
return obj;
|
|
},
|
|
setup(obj, constructorArgs, privateData) {
|
|
if (!privateData)
|
|
privateData = {};
|
|
privateData.wrapper = obj;
|
|
obj[impl] = new Impl.implementation(constructorArgs, privateData);
|
|
obj[impl][utils.wrapperSymbol] = obj;
|
|
},
|
|
interface: URL4,
|
|
expose: {
|
|
Window: { URL: URL4 },
|
|
Worker: { URL: URL4 }
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/whatwg-url/lib/public-api.js
|
|
var require_public_api = __commonJS((exports) => {
|
|
exports.URL = require_URL().interface;
|
|
exports.serializeURL = require_url_state_machine().serializeURL;
|
|
exports.serializeURLOrigin = require_url_state_machine().serializeURLOrigin;
|
|
exports.basicURLParse = require_url_state_machine().basicURLParse;
|
|
exports.setTheUsername = require_url_state_machine().setTheUsername;
|
|
exports.setThePassword = require_url_state_machine().setThePassword;
|
|
exports.serializeHost = require_url_state_machine().serializeHost;
|
|
exports.serializeInteger = require_url_state_machine().serializeInteger;
|
|
exports.parseURL = require_url_state_machine().parseURL;
|
|
});
|
|
|
|
// node_modules/node-fetch/lib/index.js
|
|
var require_lib4 = __commonJS((exports, module) => {
|
|
var _interopDefault = function(ex) {
|
|
return ex && typeof ex === "object" && ("default" in ex) ? ex["default"] : ex;
|
|
};
|
|
var FetchError = function(message, type, systemError) {
|
|
Error.call(this, message);
|
|
this.message = message;
|
|
this.type = type;
|
|
if (systemError)
|
|
this.code = this.errno = systemError.code;
|
|
Error.captureStackTrace(this, this.constructor);
|
|
};
|
|
var Body = function(body) {
|
|
var _this = this;
|
|
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, _ref$size = _ref.size;
|
|
let size = _ref$size === undefined ? 0 : _ref$size;
|
|
var _ref$timeout = _ref.timeout;
|
|
let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
|
|
if (body == null)
|
|
body = null;
|
|
else if (isURLSearchParams(body))
|
|
body = Buffer.from(body.toString());
|
|
else if (isBlob(body))
|
|
;
|
|
else if (Buffer.isBuffer(body))
|
|
;
|
|
else if (Object.prototype.toString.call(body) === "[object ArrayBuffer]")
|
|
body = Buffer.from(body);
|
|
else if (ArrayBuffer.isView(body))
|
|
body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
|
|
else if (body instanceof Stream)
|
|
;
|
|
else
|
|
body = Buffer.from(String(body));
|
|
this[INTERNALS] = {
|
|
body,
|
|
disturbed: false,
|
|
error: null
|
|
};
|
|
this.size = size;
|
|
this.timeout = timeout;
|
|
if (body instanceof Stream)
|
|
body.on("error", function(err) {
|
|
const error = err.name === "AbortError" ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, "system", err);
|
|
_this[INTERNALS].error = error;
|
|
});
|
|
};
|
|
var consumeBody = function() {
|
|
var _this4 = this;
|
|
if (this[INTERNALS].disturbed)
|
|
return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
|
|
this[INTERNALS].disturbed = true;
|
|
if (this[INTERNALS].error)
|
|
return Body.Promise.reject(this[INTERNALS].error);
|
|
let body = this.body;
|
|
if (body === null)
|
|
return Body.Promise.resolve(Buffer.alloc(0));
|
|
if (isBlob(body))
|
|
body = body.stream();
|
|
if (Buffer.isBuffer(body))
|
|
return Body.Promise.resolve(body);
|
|
if (!(body instanceof Stream))
|
|
return Body.Promise.resolve(Buffer.alloc(0));
|
|
let accum = [];
|
|
let accumBytes = 0;
|
|
let abort = false;
|
|
return new Body.Promise(function(resolve, reject) {
|
|
let resTimeout;
|
|
if (_this4.timeout)
|
|
resTimeout = setTimeout(function() {
|
|
abort = true;
|
|
reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, "body-timeout"));
|
|
}, _this4.timeout);
|
|
body.on("error", function(err) {
|
|
if (err.name === "AbortError") {
|
|
abort = true;
|
|
reject(err);
|
|
} else
|
|
reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, "system", err));
|
|
});
|
|
body.on("data", function(chunk) {
|
|
if (abort || chunk === null)
|
|
return;
|
|
if (_this4.size && accumBytes + chunk.length > _this4.size) {
|
|
abort = true;
|
|
reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, "max-size"));
|
|
return;
|
|
}
|
|
accumBytes += chunk.length;
|
|
accum.push(chunk);
|
|
});
|
|
body.on("end", function() {
|
|
if (abort)
|
|
return;
|
|
clearTimeout(resTimeout);
|
|
try {
|
|
resolve(Buffer.concat(accum, accumBytes));
|
|
} catch (err) {
|
|
reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
|
|
}
|
|
});
|
|
});
|
|
};
|
|
var convertBody = function(buffer, headers) {
|
|
if (typeof convert !== "function")
|
|
throw new Error("The package `encoding` must be installed to use the textConverted() function");
|
|
const ct = headers.get("content-type");
|
|
let charset = "utf-8";
|
|
let res, str;
|
|
if (ct)
|
|
res = /charset=([^;]*)/i.exec(ct);
|
|
str = buffer.slice(0, 1024).toString();
|
|
if (!res && str)
|
|
res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
|
|
if (!res && str) {
|
|
res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
|
|
if (!res) {
|
|
res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
|
|
if (res)
|
|
res.pop();
|
|
}
|
|
if (res)
|
|
res = /charset=(.*)/i.exec(res.pop());
|
|
}
|
|
if (!res && str)
|
|
res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
|
|
if (res) {
|
|
charset = res.pop();
|
|
if (charset === "gb2312" || charset === "gbk")
|
|
charset = "gb18030";
|
|
}
|
|
return convert(buffer, "UTF-8", charset).toString();
|
|
};
|
|
var isURLSearchParams = function(obj) {
|
|
if (typeof obj !== "object" || typeof obj.append !== "function" || typeof obj.delete !== "function" || typeof obj.get !== "function" || typeof obj.getAll !== "function" || typeof obj.has !== "function" || typeof obj.set !== "function")
|
|
return false;
|
|
return obj.constructor.name === "URLSearchParams" || Object.prototype.toString.call(obj) === "[object URLSearchParams]" || typeof obj.sort === "function";
|
|
};
|
|
var isBlob = function(obj) {
|
|
return typeof obj === "object" && typeof obj.arrayBuffer === "function" && typeof obj.type === "string" && typeof obj.stream === "function" && typeof obj.constructor === "function" && typeof obj.constructor.name === "string" && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
|
|
};
|
|
var clone = function(instance) {
|
|
let p1, p2;
|
|
let body = instance.body;
|
|
if (instance.bodyUsed)
|
|
throw new Error("cannot clone body after it is used");
|
|
if (body instanceof Stream && typeof body.getBoundary !== "function") {
|
|
p1 = new PassThrough;
|
|
p2 = new PassThrough;
|
|
body.pipe(p1);
|
|
body.pipe(p2);
|
|
instance[INTERNALS].body = p1;
|
|
body = p2;
|
|
}
|
|
return body;
|
|
};
|
|
var extractContentType = function(body) {
|
|
if (body === null)
|
|
return null;
|
|
else if (typeof body === "string")
|
|
return "text/plain;charset=UTF-8";
|
|
else if (isURLSearchParams(body))
|
|
return "application/x-www-form-urlencoded;charset=UTF-8";
|
|
else if (isBlob(body))
|
|
return body.type || null;
|
|
else if (Buffer.isBuffer(body))
|
|
return null;
|
|
else if (Object.prototype.toString.call(body) === "[object ArrayBuffer]")
|
|
return null;
|
|
else if (ArrayBuffer.isView(body))
|
|
return null;
|
|
else if (typeof body.getBoundary === "function")
|
|
return `multipart/form-data;boundary=${body.getBoundary()}`;
|
|
else if (body instanceof Stream)
|
|
return null;
|
|
else
|
|
return "text/plain;charset=UTF-8";
|
|
};
|
|
var getTotalBytes = function(instance) {
|
|
const body = instance.body;
|
|
if (body === null)
|
|
return 0;
|
|
else if (isBlob(body))
|
|
return body.size;
|
|
else if (Buffer.isBuffer(body))
|
|
return body.length;
|
|
else if (body && typeof body.getLengthSync === "function") {
|
|
if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || body.hasKnownLength && body.hasKnownLength())
|
|
return body.getLengthSync();
|
|
return null;
|
|
} else
|
|
return null;
|
|
};
|
|
var writeToStream = function(dest, instance) {
|
|
const body = instance.body;
|
|
if (body === null)
|
|
dest.end();
|
|
else if (isBlob(body))
|
|
body.stream().pipe(dest);
|
|
else if (Buffer.isBuffer(body)) {
|
|
dest.write(body);
|
|
dest.end();
|
|
} else
|
|
body.pipe(dest);
|
|
};
|
|
var validateName = function(name) {
|
|
name = `${name}`;
|
|
if (invalidTokenRegex.test(name) || name === "")
|
|
throw new TypeError(`${name} is not a legal HTTP header name`);
|
|
};
|
|
var validateValue = function(value) {
|
|
value = `${value}`;
|
|
if (invalidHeaderCharRegex.test(value))
|
|
throw new TypeError(`${value} is not a legal HTTP header value`);
|
|
};
|
|
var find = function(map, name) {
|
|
name = name.toLowerCase();
|
|
for (const key in map)
|
|
if (key.toLowerCase() === name)
|
|
return key;
|
|
return;
|
|
};
|
|
var getHeaders = function(headers) {
|
|
let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "key+value";
|
|
const keys = Object.keys(headers[MAP]).sort();
|
|
return keys.map(kind === "key" ? function(k) {
|
|
return k.toLowerCase();
|
|
} : kind === "value" ? function(k) {
|
|
return headers[MAP][k].join(", ");
|
|
} : function(k) {
|
|
return [k.toLowerCase(), headers[MAP][k].join(", ")];
|
|
});
|
|
};
|
|
var createHeadersIterator = function(target, kind) {
|
|
const iterator = Object.create(HeadersIteratorPrototype);
|
|
iterator[INTERNAL] = {
|
|
target,
|
|
kind,
|
|
index: 0
|
|
};
|
|
return iterator;
|
|
};
|
|
var exportNodeCompatibleHeaders = function(headers) {
|
|
const obj = Object.assign({ __proto__: null }, headers[MAP]);
|
|
const hostHeaderKey = find(headers[MAP], "Host");
|
|
if (hostHeaderKey !== undefined)
|
|
obj[hostHeaderKey] = obj[hostHeaderKey][0];
|
|
return obj;
|
|
};
|
|
var createHeadersLenient = function(obj) {
|
|
const headers = new Headers;
|
|
for (const name of Object.keys(obj)) {
|
|
if (invalidTokenRegex.test(name))
|
|
continue;
|
|
if (Array.isArray(obj[name]))
|
|
for (const val of obj[name]) {
|
|
if (invalidHeaderCharRegex.test(val))
|
|
continue;
|
|
if (headers[MAP][name] === undefined)
|
|
headers[MAP][name] = [val];
|
|
else
|
|
headers[MAP][name].push(val);
|
|
}
|
|
else if (!invalidHeaderCharRegex.test(obj[name]))
|
|
headers[MAP][name] = [obj[name]];
|
|
}
|
|
return headers;
|
|
};
|
|
var parseURL = function(urlStr) {
|
|
if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr))
|
|
urlStr = new URL4(urlStr).toString();
|
|
return parse_url(urlStr);
|
|
};
|
|
var isRequest = function(input) {
|
|
return typeof input === "object" && typeof input[INTERNALS$2] === "object";
|
|
};
|
|
var isAbortSignal = function(signal) {
|
|
const proto = signal && typeof signal === "object" && Object.getPrototypeOf(signal);
|
|
return !!(proto && proto.constructor.name === "AbortSignal");
|
|
};
|
|
var getNodeRequestOptions = function(request) {
|
|
const parsedURL = request[INTERNALS$2].parsedURL;
|
|
const headers = new Headers(request[INTERNALS$2].headers);
|
|
if (!headers.has("Accept"))
|
|
headers.set("Accept", "*/*");
|
|
if (!parsedURL.protocol || !parsedURL.hostname)
|
|
throw new TypeError("Only absolute URLs are supported");
|
|
if (!/^https?:$/.test(parsedURL.protocol))
|
|
throw new TypeError("Only HTTP(S) protocols are supported");
|
|
if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported)
|
|
throw new Error("Cancellation of streamed requests with AbortSignal is not supported in node < 8");
|
|
let contentLengthValue = null;
|
|
if (request.body == null && /^(POST|PUT)$/i.test(request.method))
|
|
contentLengthValue = "0";
|
|
if (request.body != null) {
|
|
const totalBytes = getTotalBytes(request);
|
|
if (typeof totalBytes === "number")
|
|
contentLengthValue = String(totalBytes);
|
|
}
|
|
if (contentLengthValue)
|
|
headers.set("Content-Length", contentLengthValue);
|
|
if (!headers.has("User-Agent"))
|
|
headers.set("User-Agent", "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)");
|
|
if (request.compress && !headers.has("Accept-Encoding"))
|
|
headers.set("Accept-Encoding", "gzip,deflate");
|
|
let agent = request.agent;
|
|
if (typeof agent === "function")
|
|
agent = agent(parsedURL);
|
|
if (!headers.has("Connection") && !agent)
|
|
headers.set("Connection", "close");
|
|
return Object.assign({}, parsedURL, {
|
|
method: request.method,
|
|
headers: exportNodeCompatibleHeaders(headers),
|
|
agent
|
|
});
|
|
};
|
|
var AbortError = function(message) {
|
|
Error.call(this, message);
|
|
this.type = "aborted";
|
|
this.message = message;
|
|
Error.captureStackTrace(this, this.constructor);
|
|
};
|
|
var fetch = function(url, opts) {
|
|
if (!fetch.Promise)
|
|
throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
|
|
Body.Promise = fetch.Promise;
|
|
return new fetch.Promise(function(resolve, reject) {
|
|
const request = new Request(url, opts);
|
|
const options = getNodeRequestOptions(request);
|
|
const send = (options.protocol === "https:" ? https : http).request;
|
|
const signal = request.signal;
|
|
let response = null;
|
|
const abort = function abort() {
|
|
let error = new AbortError("The user aborted a request.");
|
|
reject(error);
|
|
if (request.body && request.body instanceof Stream.Readable)
|
|
destroyStream(request.body, error);
|
|
if (!response || !response.body)
|
|
return;
|
|
response.body.emit("error", error);
|
|
};
|
|
if (signal && signal.aborted) {
|
|
abort();
|
|
return;
|
|
}
|
|
const abortAndFinalize = function abortAndFinalize() {
|
|
abort();
|
|
finalize();
|
|
};
|
|
const req = send(options);
|
|
let reqTimeout;
|
|
if (signal)
|
|
signal.addEventListener("abort", abortAndFinalize);
|
|
function finalize() {
|
|
req.abort();
|
|
if (signal)
|
|
signal.removeEventListener("abort", abortAndFinalize);
|
|
clearTimeout(reqTimeout);
|
|
}
|
|
if (request.timeout)
|
|
req.once("socket", function(socket) {
|
|
reqTimeout = setTimeout(function() {
|
|
reject(new FetchError(`network timeout at: ${request.url}`, "request-timeout"));
|
|
finalize();
|
|
}, request.timeout);
|
|
});
|
|
req.on("error", function(err) {
|
|
reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err));
|
|
if (response && response.body)
|
|
destroyStream(response.body, err);
|
|
finalize();
|
|
});
|
|
fixResponseChunkedTransferBadEnding(req, function(err) {
|
|
if (signal && signal.aborted)
|
|
return;
|
|
if (response && response.body)
|
|
destroyStream(response.body, err);
|
|
});
|
|
if (parseInt(process.version.substring(1)) < 14)
|
|
req.on("socket", function(s) {
|
|
s.addListener("close", function(hadError) {
|
|
const hasDataListener = s.listenerCount("data") > 0;
|
|
if (response && hasDataListener && !hadError && !(signal && signal.aborted)) {
|
|
const err = new Error("Premature close");
|
|
err.code = "ERR_STREAM_PREMATURE_CLOSE";
|
|
response.body.emit("error", err);
|
|
}
|
|
});
|
|
});
|
|
req.on("response", function(res) {
|
|
clearTimeout(reqTimeout);
|
|
const headers = createHeadersLenient(res.headers);
|
|
if (fetch.isRedirect(res.statusCode)) {
|
|
const location = headers.get("Location");
|
|
let locationURL = null;
|
|
try {
|
|
locationURL = location === null ? null : new URL$1(location, request.url).toString();
|
|
} catch (err) {
|
|
if (request.redirect !== "manual") {
|
|
reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, "invalid-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
}
|
|
switch (request.redirect) {
|
|
case "error":
|
|
reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, "no-redirect"));
|
|
finalize();
|
|
return;
|
|
case "manual":
|
|
if (locationURL !== null)
|
|
try {
|
|
headers.set("Location", locationURL);
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
break;
|
|
case "follow":
|
|
if (locationURL === null)
|
|
break;
|
|
if (request.counter >= request.follow) {
|
|
reject(new FetchError(`maximum redirect reached at: ${request.url}`, "max-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
const requestOpts = {
|
|
headers: new Headers(request.headers),
|
|
follow: request.follow,
|
|
counter: request.counter + 1,
|
|
agent: request.agent,
|
|
compress: request.compress,
|
|
method: request.method,
|
|
body: request.body,
|
|
signal: request.signal,
|
|
timeout: request.timeout,
|
|
size: request.size
|
|
};
|
|
if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL))
|
|
for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"])
|
|
requestOpts.headers.delete(name);
|
|
if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
|
|
reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
|
|
finalize();
|
|
return;
|
|
}
|
|
if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === "POST") {
|
|
requestOpts.method = "GET";
|
|
requestOpts.body = undefined;
|
|
requestOpts.headers.delete("content-length");
|
|
}
|
|
resolve(fetch(new Request(locationURL, requestOpts)));
|
|
finalize();
|
|
return;
|
|
}
|
|
}
|
|
res.once("end", function() {
|
|
if (signal)
|
|
signal.removeEventListener("abort", abortAndFinalize);
|
|
});
|
|
let body = res.pipe(new PassThrough$1);
|
|
const response_options = {
|
|
url: request.url,
|
|
status: res.statusCode,
|
|
statusText: res.statusMessage,
|
|
headers,
|
|
size: request.size,
|
|
timeout: request.timeout,
|
|
counter: request.counter
|
|
};
|
|
const codings = headers.get("Content-Encoding");
|
|
if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
const zlibOptions = {
|
|
flush: zlib.Z_SYNC_FLUSH,
|
|
finishFlush: zlib.Z_SYNC_FLUSH
|
|
};
|
|
if (codings == "gzip" || codings == "x-gzip") {
|
|
body = body.pipe(zlib.createGunzip(zlibOptions));
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
if (codings == "deflate" || codings == "x-deflate") {
|
|
const raw = res.pipe(new PassThrough$1);
|
|
raw.once("data", function(chunk) {
|
|
if ((chunk[0] & 15) === 8)
|
|
body = body.pipe(zlib.createInflate());
|
|
else
|
|
body = body.pipe(zlib.createInflateRaw());
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
});
|
|
raw.on("end", function() {
|
|
if (!response) {
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
|
|
body = body.pipe(zlib.createBrotliDecompress());
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
return;
|
|
}
|
|
response = new Response(body, response_options);
|
|
resolve(response);
|
|
});
|
|
writeToStream(req, request);
|
|
});
|
|
};
|
|
var fixResponseChunkedTransferBadEnding = function(request, errorCallback) {
|
|
let socket;
|
|
request.on("socket", function(s) {
|
|
socket = s;
|
|
});
|
|
request.on("response", function(response) {
|
|
const headers = response.headers;
|
|
if (headers["transfer-encoding"] === "chunked" && !headers["content-length"])
|
|
response.once("close", function(hadError) {
|
|
const hasDataListener = socket.listenerCount("data") > 0;
|
|
if (hasDataListener && !hadError) {
|
|
const err = new Error("Premature close");
|
|
err.code = "ERR_STREAM_PREMATURE_CLOSE";
|
|
errorCallback(err);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
var destroyStream = function(stream, err) {
|
|
if (stream.destroy)
|
|
stream.destroy(err);
|
|
else {
|
|
stream.emit("error", err);
|
|
stream.end();
|
|
}
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var Stream = _interopDefault(__require("stream"));
|
|
var http = _interopDefault(__require("http"));
|
|
var Url = _interopDefault(__require("url"));
|
|
var whatwgUrl = _interopDefault(require_public_api());
|
|
var https = _interopDefault(__require("https"));
|
|
var zlib = _interopDefault(__require("zlib"));
|
|
var Readable = Stream.Readable;
|
|
var BUFFER = Symbol("buffer");
|
|
var TYPE = Symbol("type");
|
|
|
|
class Blob2 {
|
|
constructor() {
|
|
this[TYPE] = "";
|
|
const blobParts = arguments[0];
|
|
const options = arguments[1];
|
|
const buffers = [];
|
|
let size = 0;
|
|
if (blobParts) {
|
|
const a = blobParts;
|
|
const length = Number(a.length);
|
|
for (let i = 0;i < length; i++) {
|
|
const element = a[i];
|
|
let buffer;
|
|
if (element instanceof Buffer)
|
|
buffer = element;
|
|
else if (ArrayBuffer.isView(element))
|
|
buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
|
|
else if (element instanceof ArrayBuffer)
|
|
buffer = Buffer.from(element);
|
|
else if (element instanceof Blob2)
|
|
buffer = element[BUFFER];
|
|
else
|
|
buffer = Buffer.from(typeof element === "string" ? element : String(element));
|
|
size += buffer.length;
|
|
buffers.push(buffer);
|
|
}
|
|
}
|
|
this[BUFFER] = Buffer.concat(buffers);
|
|
let type = options && options.type !== undefined && String(options.type).toLowerCase();
|
|
if (type && !/[^\u0020-\u007E]/.test(type))
|
|
this[TYPE] = type;
|
|
}
|
|
get size() {
|
|
return this[BUFFER].length;
|
|
}
|
|
get type() {
|
|
return this[TYPE];
|
|
}
|
|
text() {
|
|
return Promise.resolve(this[BUFFER].toString());
|
|
}
|
|
arrayBuffer() {
|
|
const buf = this[BUFFER];
|
|
const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
|
return Promise.resolve(ab);
|
|
}
|
|
stream() {
|
|
const readable = new Readable;
|
|
readable._read = function() {
|
|
};
|
|
readable.push(this[BUFFER]);
|
|
readable.push(null);
|
|
return readable;
|
|
}
|
|
toString() {
|
|
return "[object Blob]";
|
|
}
|
|
slice() {
|
|
const size = this.size;
|
|
const start = arguments[0];
|
|
const end = arguments[1];
|
|
let relativeStart, relativeEnd;
|
|
if (start === undefined)
|
|
relativeStart = 0;
|
|
else if (start < 0)
|
|
relativeStart = Math.max(size + start, 0);
|
|
else
|
|
relativeStart = Math.min(start, size);
|
|
if (end === undefined)
|
|
relativeEnd = size;
|
|
else if (end < 0)
|
|
relativeEnd = Math.max(size + end, 0);
|
|
else
|
|
relativeEnd = Math.min(end, size);
|
|
const span = Math.max(relativeEnd - relativeStart, 0);
|
|
const buffer = this[BUFFER];
|
|
const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
|
|
const blob = new Blob2([], { type: arguments[2] });
|
|
blob[BUFFER] = slicedBuffer;
|
|
return blob;
|
|
}
|
|
}
|
|
Object.defineProperties(Blob2.prototype, {
|
|
size: { enumerable: true },
|
|
type: { enumerable: true },
|
|
slice: { enumerable: true }
|
|
});
|
|
Object.defineProperty(Blob2.prototype, Symbol.toStringTag, {
|
|
value: "Blob",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
FetchError.prototype = Object.create(Error.prototype);
|
|
FetchError.prototype.constructor = FetchError;
|
|
FetchError.prototype.name = "FetchError";
|
|
var convert;
|
|
try {
|
|
convert = (() => { throw (new Error(`Cannot require module "encoding"`)); } )().convert;
|
|
} catch (e) {
|
|
}
|
|
var INTERNALS = Symbol("Body internals");
|
|
var PassThrough = Stream.PassThrough;
|
|
Body.prototype = {
|
|
get body() {
|
|
return this[INTERNALS].body;
|
|
},
|
|
get bodyUsed() {
|
|
return this[INTERNALS].disturbed;
|
|
},
|
|
arrayBuffer() {
|
|
return consumeBody.call(this).then(function(buf) {
|
|
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
|
});
|
|
},
|
|
blob() {
|
|
let ct = this.headers && this.headers.get("content-type") || "";
|
|
return consumeBody.call(this).then(function(buf) {
|
|
return Object.assign(new Blob2([], {
|
|
type: ct.toLowerCase()
|
|
}), {
|
|
[BUFFER]: buf
|
|
});
|
|
});
|
|
},
|
|
json() {
|
|
var _this2 = this;
|
|
return consumeBody.call(this).then(function(buffer) {
|
|
try {
|
|
return JSON.parse(buffer.toString());
|
|
} catch (err) {
|
|
return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, "invalid-json"));
|
|
}
|
|
});
|
|
},
|
|
text() {
|
|
return consumeBody.call(this).then(function(buffer) {
|
|
return buffer.toString();
|
|
});
|
|
},
|
|
buffer() {
|
|
return consumeBody.call(this);
|
|
},
|
|
textConverted() {
|
|
var _this3 = this;
|
|
return consumeBody.call(this).then(function(buffer) {
|
|
return convertBody(buffer, _this3.headers);
|
|
});
|
|
}
|
|
};
|
|
Object.defineProperties(Body.prototype, {
|
|
body: { enumerable: true },
|
|
bodyUsed: { enumerable: true },
|
|
arrayBuffer: { enumerable: true },
|
|
blob: { enumerable: true },
|
|
json: { enumerable: true },
|
|
text: { enumerable: true }
|
|
});
|
|
Body.mixIn = function(proto) {
|
|
for (const name of Object.getOwnPropertyNames(Body.prototype))
|
|
if (!(name in proto)) {
|
|
const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
|
|
Object.defineProperty(proto, name, desc);
|
|
}
|
|
};
|
|
Body.Promise = global.Promise;
|
|
var invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
|
|
var invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
|
|
var MAP = Symbol("map");
|
|
|
|
class Headers {
|
|
constructor() {
|
|
let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
|
|
this[MAP] = Object.create(null);
|
|
if (init instanceof Headers) {
|
|
const rawHeaders = init.raw();
|
|
const headerNames = Object.keys(rawHeaders);
|
|
for (const headerName of headerNames)
|
|
for (const value of rawHeaders[headerName])
|
|
this.append(headerName, value);
|
|
return;
|
|
}
|
|
if (init == null)
|
|
;
|
|
else if (typeof init === "object") {
|
|
const method = init[Symbol.iterator];
|
|
if (method != null) {
|
|
if (typeof method !== "function")
|
|
throw new TypeError("Header pairs must be iterable");
|
|
const pairs = [];
|
|
for (const pair of init) {
|
|
if (typeof pair !== "object" || typeof pair[Symbol.iterator] !== "function")
|
|
throw new TypeError("Each header pair must be iterable");
|
|
pairs.push(Array.from(pair));
|
|
}
|
|
for (const pair of pairs) {
|
|
if (pair.length !== 2)
|
|
throw new TypeError("Each header pair must be a name/value tuple");
|
|
this.append(pair[0], pair[1]);
|
|
}
|
|
} else
|
|
for (const key of Object.keys(init)) {
|
|
const value = init[key];
|
|
this.append(key, value);
|
|
}
|
|
} else
|
|
throw new TypeError("Provided initializer must be an object");
|
|
}
|
|
get(name) {
|
|
name = `${name}`;
|
|
validateName(name);
|
|
const key = find(this[MAP], name);
|
|
if (key === undefined)
|
|
return null;
|
|
return this[MAP][key].join(", ");
|
|
}
|
|
forEach(callback) {
|
|
let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
|
|
let pairs = getHeaders(this);
|
|
let i = 0;
|
|
while (i < pairs.length) {
|
|
var _pairs$i = pairs[i];
|
|
const name = _pairs$i[0], value = _pairs$i[1];
|
|
callback.call(thisArg, value, name, this);
|
|
pairs = getHeaders(this);
|
|
i++;
|
|
}
|
|
}
|
|
set(name, value) {
|
|
name = `${name}`;
|
|
value = `${value}`;
|
|
validateName(name);
|
|
validateValue(value);
|
|
const key = find(this[MAP], name);
|
|
this[MAP][key !== undefined ? key : name] = [value];
|
|
}
|
|
append(name, value) {
|
|
name = `${name}`;
|
|
value = `${value}`;
|
|
validateName(name);
|
|
validateValue(value);
|
|
const key = find(this[MAP], name);
|
|
if (key !== undefined)
|
|
this[MAP][key].push(value);
|
|
else
|
|
this[MAP][name] = [value];
|
|
}
|
|
has(name) {
|
|
name = `${name}`;
|
|
validateName(name);
|
|
return find(this[MAP], name) !== undefined;
|
|
}
|
|
delete(name) {
|
|
name = `${name}`;
|
|
validateName(name);
|
|
const key = find(this[MAP], name);
|
|
if (key !== undefined)
|
|
delete this[MAP][key];
|
|
}
|
|
raw() {
|
|
return this[MAP];
|
|
}
|
|
keys() {
|
|
return createHeadersIterator(this, "key");
|
|
}
|
|
values() {
|
|
return createHeadersIterator(this, "value");
|
|
}
|
|
[Symbol.iterator]() {
|
|
return createHeadersIterator(this, "key+value");
|
|
}
|
|
}
|
|
Headers.prototype.entries = Headers.prototype[Symbol.iterator];
|
|
Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
|
|
value: "Headers",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperties(Headers.prototype, {
|
|
get: { enumerable: true },
|
|
forEach: { enumerable: true },
|
|
set: { enumerable: true },
|
|
append: { enumerable: true },
|
|
has: { enumerable: true },
|
|
delete: { enumerable: true },
|
|
keys: { enumerable: true },
|
|
values: { enumerable: true },
|
|
entries: { enumerable: true }
|
|
});
|
|
var INTERNAL = Symbol("internal");
|
|
var HeadersIteratorPrototype = Object.setPrototypeOf({
|
|
next() {
|
|
if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype)
|
|
throw new TypeError("Value of `this` is not a HeadersIterator");
|
|
var _INTERNAL = this[INTERNAL];
|
|
const { target, kind, index } = _INTERNAL;
|
|
const values = getHeaders(target, kind);
|
|
const len = values.length;
|
|
if (index >= len)
|
|
return {
|
|
value: undefined,
|
|
done: true
|
|
};
|
|
this[INTERNAL].index = index + 1;
|
|
return {
|
|
value: values[index],
|
|
done: false
|
|
};
|
|
}
|
|
}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
|
|
Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
|
|
value: "HeadersIterator",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
var INTERNALS$1 = Symbol("Response internals");
|
|
var STATUS_CODES = http.STATUS_CODES;
|
|
|
|
class Response {
|
|
constructor() {
|
|
let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
|
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
Body.call(this, body, opts);
|
|
const status = opts.status || 200;
|
|
const headers = new Headers(opts.headers);
|
|
if (body != null && !headers.has("Content-Type")) {
|
|
const contentType = extractContentType(body);
|
|
if (contentType)
|
|
headers.append("Content-Type", contentType);
|
|
}
|
|
this[INTERNALS$1] = {
|
|
url: opts.url,
|
|
status,
|
|
statusText: opts.statusText || STATUS_CODES[status],
|
|
headers,
|
|
counter: opts.counter
|
|
};
|
|
}
|
|
get url() {
|
|
return this[INTERNALS$1].url || "";
|
|
}
|
|
get status() {
|
|
return this[INTERNALS$1].status;
|
|
}
|
|
get ok() {
|
|
return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
|
|
}
|
|
get redirected() {
|
|
return this[INTERNALS$1].counter > 0;
|
|
}
|
|
get statusText() {
|
|
return this[INTERNALS$1].statusText;
|
|
}
|
|
get headers() {
|
|
return this[INTERNALS$1].headers;
|
|
}
|
|
clone() {
|
|
return new Response(clone(this), {
|
|
url: this.url,
|
|
status: this.status,
|
|
statusText: this.statusText,
|
|
headers: this.headers,
|
|
ok: this.ok,
|
|
redirected: this.redirected
|
|
});
|
|
}
|
|
}
|
|
Body.mixIn(Response.prototype);
|
|
Object.defineProperties(Response.prototype, {
|
|
url: { enumerable: true },
|
|
status: { enumerable: true },
|
|
ok: { enumerable: true },
|
|
redirected: { enumerable: true },
|
|
statusText: { enumerable: true },
|
|
headers: { enumerable: true },
|
|
clone: { enumerable: true }
|
|
});
|
|
Object.defineProperty(Response.prototype, Symbol.toStringTag, {
|
|
value: "Response",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
var INTERNALS$2 = Symbol("Request internals");
|
|
var URL4 = Url.URL || whatwgUrl.URL;
|
|
var parse_url = Url.parse;
|
|
var format_url = Url.format;
|
|
var streamDestructionSupported = "destroy" in Stream.Readable.prototype;
|
|
|
|
class Request {
|
|
constructor(input) {
|
|
let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
let parsedURL;
|
|
if (!isRequest(input)) {
|
|
if (input && input.href)
|
|
parsedURL = parseURL(input.href);
|
|
else
|
|
parsedURL = parseURL(`${input}`);
|
|
input = {};
|
|
} else
|
|
parsedURL = parseURL(input.url);
|
|
let method = init.method || input.method || "GET";
|
|
method = method.toUpperCase();
|
|
if ((init.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD"))
|
|
throw new TypeError("Request with GET/HEAD method cannot have body");
|
|
let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
|
|
Body.call(this, inputBody, {
|
|
timeout: init.timeout || input.timeout || 0,
|
|
size: init.size || input.size || 0
|
|
});
|
|
const headers = new Headers(init.headers || input.headers || {});
|
|
if (inputBody != null && !headers.has("Content-Type")) {
|
|
const contentType = extractContentType(inputBody);
|
|
if (contentType)
|
|
headers.append("Content-Type", contentType);
|
|
}
|
|
let signal = isRequest(input) ? input.signal : null;
|
|
if ("signal" in init)
|
|
signal = init.signal;
|
|
if (signal != null && !isAbortSignal(signal))
|
|
throw new TypeError("Expected signal to be an instanceof AbortSignal");
|
|
this[INTERNALS$2] = {
|
|
method,
|
|
redirect: init.redirect || input.redirect || "follow",
|
|
headers,
|
|
parsedURL,
|
|
signal
|
|
};
|
|
this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
|
|
this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
|
|
this.counter = init.counter || input.counter || 0;
|
|
this.agent = init.agent || input.agent;
|
|
}
|
|
get method() {
|
|
return this[INTERNALS$2].method;
|
|
}
|
|
get url() {
|
|
return format_url(this[INTERNALS$2].parsedURL);
|
|
}
|
|
get headers() {
|
|
return this[INTERNALS$2].headers;
|
|
}
|
|
get redirect() {
|
|
return this[INTERNALS$2].redirect;
|
|
}
|
|
get signal() {
|
|
return this[INTERNALS$2].signal;
|
|
}
|
|
clone() {
|
|
return new Request(this);
|
|
}
|
|
}
|
|
Body.mixIn(Request.prototype);
|
|
Object.defineProperty(Request.prototype, Symbol.toStringTag, {
|
|
value: "Request",
|
|
writable: false,
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
Object.defineProperties(Request.prototype, {
|
|
method: { enumerable: true },
|
|
url: { enumerable: true },
|
|
headers: { enumerable: true },
|
|
redirect: { enumerable: true },
|
|
clone: { enumerable: true },
|
|
signal: { enumerable: true }
|
|
});
|
|
AbortError.prototype = Object.create(Error.prototype);
|
|
AbortError.prototype.constructor = AbortError;
|
|
AbortError.prototype.name = "AbortError";
|
|
var URL$1 = Url.URL || whatwgUrl.URL;
|
|
var PassThrough$1 = Stream.PassThrough;
|
|
var isDomainOrSubdomain = function isDomainOrSubdomain(destination, original) {
|
|
const orig = new URL$1(original).hostname;
|
|
const dest = new URL$1(destination).hostname;
|
|
return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest);
|
|
};
|
|
var isSameProtocol = function isSameProtocol(destination, original) {
|
|
const orig = new URL$1(original).protocol;
|
|
const dest = new URL$1(destination).protocol;
|
|
return orig === dest;
|
|
};
|
|
fetch.isRedirect = function(code) {
|
|
return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
|
|
};
|
|
fetch.Promise = global.Promise;
|
|
module.exports = exports = fetch;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.default = exports;
|
|
exports.Headers = Headers;
|
|
exports.Request = Request;
|
|
exports.Response = Response;
|
|
exports.FetchError = FetchError;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
|
|
var require_globalThis = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports._globalThis = undefined;
|
|
exports._globalThis = typeof globalThis === "object" ? globalThis : global;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/platform/node/index.js
|
|
var require_node = __commonJS((exports) => {
|
|
var __createBinding2 = exports && exports.__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 __exportStar2 = exports && exports.__exportStar || function(m, exports2) {
|
|
for (var p in m)
|
|
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
|
|
__createBinding2(exports2, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__exportStar2(require_globalThis(), exports);
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/platform/index.js
|
|
var require_platform = __commonJS((exports) => {
|
|
var __createBinding2 = exports && exports.__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 __exportStar2 = exports && exports.__exportStar || function(m, exports2) {
|
|
for (var p in m)
|
|
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
|
|
__createBinding2(exports2, m, p);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
__exportStar2(require_node(), exports);
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/version.js
|
|
var require_version = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.VERSION = undefined;
|
|
exports.VERSION = "1.4.1";
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/internal/semver.js
|
|
var require_semver2 = __commonJS((exports) => {
|
|
var _makeCompatibilityCheck = function(ownVersion) {
|
|
const acceptedVersions = new Set([ownVersion]);
|
|
const rejectedVersions = new Set;
|
|
const myVersionMatch = ownVersion.match(re);
|
|
if (!myVersionMatch)
|
|
return () => false;
|
|
const ownVersionParsed = {
|
|
major: +myVersionMatch[1],
|
|
minor: +myVersionMatch[2],
|
|
patch: +myVersionMatch[3],
|
|
prerelease: myVersionMatch[4]
|
|
};
|
|
if (ownVersionParsed.prerelease != null)
|
|
return function isExactmatch(globalVersion) {
|
|
return globalVersion === ownVersion;
|
|
};
|
|
function _reject(v) {
|
|
rejectedVersions.add(v);
|
|
return false;
|
|
}
|
|
function _accept(v) {
|
|
acceptedVersions.add(v);
|
|
return true;
|
|
}
|
|
return function isCompatible(globalVersion) {
|
|
if (acceptedVersions.has(globalVersion))
|
|
return true;
|
|
if (rejectedVersions.has(globalVersion))
|
|
return false;
|
|
const globalVersionMatch = globalVersion.match(re);
|
|
if (!globalVersionMatch)
|
|
return _reject(globalVersion);
|
|
const globalVersionParsed = {
|
|
major: +globalVersionMatch[1],
|
|
minor: +globalVersionMatch[2],
|
|
patch: +globalVersionMatch[3],
|
|
prerelease: globalVersionMatch[4]
|
|
};
|
|
if (globalVersionParsed.prerelease != null)
|
|
return _reject(globalVersion);
|
|
if (ownVersionParsed.major !== globalVersionParsed.major)
|
|
return _reject(globalVersion);
|
|
if (ownVersionParsed.major === 0) {
|
|
if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch)
|
|
return _accept(globalVersion);
|
|
return _reject(globalVersion);
|
|
}
|
|
if (ownVersionParsed.minor <= globalVersionParsed.minor)
|
|
return _accept(globalVersion);
|
|
return _reject(globalVersion);
|
|
};
|
|
};
|
|
exports._makeCompatibilityCheck = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.isCompatible = exports._makeCompatibilityCheck = undefined;
|
|
var version_1 = require_version();
|
|
var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
|
|
exports._makeCompatibilityCheck = _makeCompatibilityCheck;
|
|
exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/internal/global-utils.js
|
|
var require_global_utils = __commonJS((exports) => {
|
|
var registerGlobal = function(type, instance, diag, allowOverride = false) {
|
|
var _a;
|
|
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== undefined ? _a : {
|
|
version: version_1.VERSION
|
|
};
|
|
if (!allowOverride && api[type]) {
|
|
const 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) {
|
|
const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
|
|
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;
|
|
};
|
|
var getGlobal = function(type) {
|
|
var _a, _b;
|
|
const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === undefined ? undefined : _a.version;
|
|
if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion))
|
|
return;
|
|
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === undefined ? undefined : _b[type];
|
|
};
|
|
var unregisterGlobal = function(type, diag) {
|
|
diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
|
|
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
|
|
if (api)
|
|
delete api[type];
|
|
};
|
|
exports.getGlobal = undefined;
|
|
exports.registerGlobal = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = undefined;
|
|
var platform_1 = require_platform();
|
|
var version_1 = require_version();
|
|
var semver_1 = require_semver2();
|
|
var major = version_1.VERSION.split(".")[0];
|
|
var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
|
|
var _global = platform_1._globalThis;
|
|
exports.registerGlobal = registerGlobal;
|
|
exports.getGlobal = getGlobal;
|
|
exports.unregisterGlobal = unregisterGlobal;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
|
|
var require_ComponentLogger = __commonJS((exports) => {
|
|
var logProxy = function(funcName, namespace, args) {
|
|
const logger = (0, global_utils_1.getGlobal)("diag");
|
|
if (!logger)
|
|
return;
|
|
args.unshift(namespace);
|
|
return logger[funcName](...args);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DiagComponentLogger = undefined;
|
|
var global_utils_1 = require_global_utils();
|
|
|
|
class DiagComponentLogger {
|
|
constructor(props) {
|
|
this._namespace = props.namespace || "DiagComponentLogger";
|
|
}
|
|
debug(...args) {
|
|
return logProxy("debug", this._namespace, args);
|
|
}
|
|
error(...args) {
|
|
return logProxy("error", this._namespace, args);
|
|
}
|
|
info(...args) {
|
|
return logProxy("info", this._namespace, args);
|
|
}
|
|
warn(...args) {
|
|
return logProxy("warn", this._namespace, args);
|
|
}
|
|
verbose(...args) {
|
|
return logProxy("verbose", this._namespace, args);
|
|
}
|
|
}
|
|
exports.DiagComponentLogger = DiagComponentLogger;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/diag/types.js
|
|
var require_types = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DiagLogLevel = undefined;
|
|
var DiagLogLevel;
|
|
(function(DiagLogLevel2) {
|
|
DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
|
|
DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
|
|
DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
|
|
DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
|
|
DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
|
|
DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
|
|
DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
|
|
})(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
|
|
var require_logLevelLogger = __commonJS((exports) => {
|
|
var createLogLevelDiagLogger = function(maxLevel, logger) {
|
|
if (maxLevel < types_1.DiagLogLevel.NONE)
|
|
maxLevel = types_1.DiagLogLevel.NONE;
|
|
else if (maxLevel > types_1.DiagLogLevel.ALL)
|
|
maxLevel = types_1.DiagLogLevel.ALL;
|
|
logger = logger || {};
|
|
function _filterFunc(funcName, theLevel) {
|
|
const theFunc = logger[funcName];
|
|
if (typeof theFunc === "function" && maxLevel >= theLevel)
|
|
return theFunc.bind(logger);
|
|
return function() {
|
|
};
|
|
}
|
|
return {
|
|
error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
|
|
warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
|
|
info: _filterFunc("info", types_1.DiagLogLevel.INFO),
|
|
debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
|
|
verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
|
|
};
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createLogLevelDiagLogger = undefined;
|
|
var types_1 = require_types();
|
|
exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/api/diag.js
|
|
var require_diag = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DiagAPI = undefined;
|
|
var ComponentLogger_1 = require_ComponentLogger();
|
|
var logLevelLogger_1 = require_logLevelLogger();
|
|
var types_1 = require_types();
|
|
var global_utils_1 = require_global_utils();
|
|
var API_NAME = "diag";
|
|
|
|
class DiagAPI {
|
|
constructor() {
|
|
function _logProxy(funcName) {
|
|
return function(...args) {
|
|
const logger = (0, global_utils_1.getGlobal)("diag");
|
|
if (!logger)
|
|
return;
|
|
return logger[funcName](...args);
|
|
};
|
|
}
|
|
const self = this;
|
|
const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
|
|
var _a, _b, _c;
|
|
if (logger === self) {
|
|
const 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 !== undefined ? _a : err.message);
|
|
return false;
|
|
}
|
|
if (typeof optionsOrLogLevel === "number")
|
|
optionsOrLogLevel = {
|
|
logLevel: optionsOrLogLevel
|
|
};
|
|
const oldLogger = (0, global_utils_1.getGlobal)("diag");
|
|
const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== undefined ? _b : types_1.DiagLogLevel.INFO, logger);
|
|
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
|
|
const stack = (_c = new Error().stack) !== null && _c !== undefined ? _c : "<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 (0, global_utils_1.registerGlobal)("diag", newLogger, self, true);
|
|
};
|
|
self.setLogger = setLogger;
|
|
self.disable = () => {
|
|
(0, global_utils_1.unregisterGlobal)(API_NAME, self);
|
|
};
|
|
self.createComponentLogger = (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");
|
|
}
|
|
static instance() {
|
|
if (!this._instance)
|
|
this._instance = new DiagAPI;
|
|
return this._instance;
|
|
}
|
|
}
|
|
exports.DiagAPI = DiagAPI;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
|
|
var require_baggage_impl = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.BaggageImpl = undefined;
|
|
|
|
class BaggageImpl {
|
|
constructor(entries) {
|
|
this._entries = entries ? new Map(entries) : new Map;
|
|
}
|
|
getEntry(key) {
|
|
const entry = this._entries.get(key);
|
|
if (!entry)
|
|
return;
|
|
return Object.assign({}, entry);
|
|
}
|
|
getAllEntries() {
|
|
return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
|
|
}
|
|
setEntry(key, entry) {
|
|
const newBaggage = new BaggageImpl(this._entries);
|
|
newBaggage._entries.set(key, entry);
|
|
return newBaggage;
|
|
}
|
|
removeEntry(key) {
|
|
const newBaggage = new BaggageImpl(this._entries);
|
|
newBaggage._entries.delete(key);
|
|
return newBaggage;
|
|
}
|
|
removeEntries(...keys) {
|
|
const newBaggage = new BaggageImpl(this._entries);
|
|
for (const key of keys)
|
|
newBaggage._entries.delete(key);
|
|
return newBaggage;
|
|
}
|
|
clear() {
|
|
return new BaggageImpl;
|
|
}
|
|
}
|
|
exports.BaggageImpl = BaggageImpl;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
|
|
var require_symbol = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.baggageEntryMetadataSymbol = undefined;
|
|
exports.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/baggage/utils.js
|
|
var require_utils3 = __commonJS((exports) => {
|
|
var createBaggage = function(entries = {}) {
|
|
return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
|
|
};
|
|
var baggageEntryMetadataFromString = function(str) {
|
|
if (typeof str !== "string") {
|
|
diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
|
|
str = "";
|
|
}
|
|
return {
|
|
__TYPE__: symbol_1.baggageEntryMetadataSymbol,
|
|
toString() {
|
|
return str;
|
|
}
|
|
};
|
|
};
|
|
exports.createBaggage = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.baggageEntryMetadataFromString = exports.createBaggage = undefined;
|
|
var diag_1 = require_diag();
|
|
var baggage_impl_1 = require_baggage_impl();
|
|
var symbol_1 = require_symbol();
|
|
var diag = diag_1.DiagAPI.instance();
|
|
exports.createBaggage = createBaggage;
|
|
exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/context/context.js
|
|
var require_context = __commonJS((exports) => {
|
|
var createContextKey = function(description) {
|
|
return Symbol.for(description);
|
|
};
|
|
exports.createContextKey = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ROOT_CONTEXT = exports.createContextKey = undefined;
|
|
exports.createContextKey = createContextKey;
|
|
|
|
class BaseContext {
|
|
constructor(parentContext) {
|
|
const self = this;
|
|
self._currentContext = parentContext ? new Map(parentContext) : new Map;
|
|
self.getValue = (key) => self._currentContext.get(key);
|
|
self.setValue = (key, value) => {
|
|
const context = new BaseContext(self._currentContext);
|
|
context._currentContext.set(key, value);
|
|
return context;
|
|
};
|
|
self.deleteValue = (key) => {
|
|
const context = new BaseContext(self._currentContext);
|
|
context._currentContext.delete(key);
|
|
return context;
|
|
};
|
|
}
|
|
}
|
|
exports.ROOT_CONTEXT = new BaseContext;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
|
|
var require_consoleLogger = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.DiagConsoleLogger = undefined;
|
|
var consoleMap = [
|
|
{ n: "error", c: "error" },
|
|
{ n: "warn", c: "warn" },
|
|
{ n: "info", c: "info" },
|
|
{ n: "debug", c: "debug" },
|
|
{ n: "verbose", c: "trace" }
|
|
];
|
|
|
|
class DiagConsoleLogger {
|
|
constructor() {
|
|
function _consoleFunc(funcName) {
|
|
return function(...args) {
|
|
if (console) {
|
|
let theFunc = console[funcName];
|
|
if (typeof theFunc !== "function")
|
|
theFunc = console.log;
|
|
if (typeof theFunc === "function")
|
|
return theFunc.apply(console, args);
|
|
}
|
|
};
|
|
}
|
|
for (let i = 0;i < consoleMap.length; i++)
|
|
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
|
|
}
|
|
}
|
|
exports.DiagConsoleLogger = DiagConsoleLogger;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
|
|
var require_NoopMeter = __commonJS((exports) => {
|
|
var createNoopMeter = function() {
|
|
return exports.NOOP_METER;
|
|
};
|
|
exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = undefined;
|
|
exports.NOOP_OBSERVABLE_GAUGE_METRIC = undefined;
|
|
exports.NOOP_OBSERVABLE_COUNTER_METRIC = undefined;
|
|
exports.NOOP_UP_DOWN_COUNTER_METRIC = undefined;
|
|
exports.NOOP_HISTOGRAM_METRIC = undefined;
|
|
exports.NOOP_COUNTER_METRIC = undefined;
|
|
exports.NOOP_METER = undefined;
|
|
exports.NoopObservableUpDownCounterMetric = undefined;
|
|
exports.NoopObservableGaugeMetric = undefined;
|
|
exports.NoopObservableCounterMetric = undefined;
|
|
exports.NoopObservableMetric = undefined;
|
|
exports.NoopHistogramMetric = undefined;
|
|
exports.NoopUpDownCounterMetric = undefined;
|
|
exports.NoopCounterMetric = undefined;
|
|
exports.NoopMetric = undefined;
|
|
exports.NoopMeter = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = undefined;
|
|
|
|
class NoopMeter {
|
|
constructor() {
|
|
}
|
|
createHistogram(_name, _options) {
|
|
return exports.NOOP_HISTOGRAM_METRIC;
|
|
}
|
|
createCounter(_name, _options) {
|
|
return exports.NOOP_COUNTER_METRIC;
|
|
}
|
|
createUpDownCounter(_name, _options) {
|
|
return exports.NOOP_UP_DOWN_COUNTER_METRIC;
|
|
}
|
|
createObservableGauge(_name, _options) {
|
|
return exports.NOOP_OBSERVABLE_GAUGE_METRIC;
|
|
}
|
|
createObservableCounter(_name, _options) {
|
|
return exports.NOOP_OBSERVABLE_COUNTER_METRIC;
|
|
}
|
|
createObservableUpDownCounter(_name, _options) {
|
|
return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
|
|
}
|
|
addBatchObservableCallback(_callback, _observables) {
|
|
}
|
|
removeBatchObservableCallback(_callback) {
|
|
}
|
|
}
|
|
exports.NoopMeter = NoopMeter;
|
|
|
|
class NoopMetric {
|
|
}
|
|
exports.NoopMetric = NoopMetric;
|
|
|
|
class NoopCounterMetric extends NoopMetric {
|
|
add(_value, _attributes) {
|
|
}
|
|
}
|
|
exports.NoopCounterMetric = NoopCounterMetric;
|
|
|
|
class NoopUpDownCounterMetric extends NoopMetric {
|
|
add(_value, _attributes) {
|
|
}
|
|
}
|
|
exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
|
|
|
|
class NoopHistogramMetric extends NoopMetric {
|
|
record(_value, _attributes) {
|
|
}
|
|
}
|
|
exports.NoopHistogramMetric = NoopHistogramMetric;
|
|
|
|
class NoopObservableMetric {
|
|
addCallback(_callback) {
|
|
}
|
|
removeCallback(_callback) {
|
|
}
|
|
}
|
|
exports.NoopObservableMetric = NoopObservableMetric;
|
|
|
|
class NoopObservableCounterMetric extends NoopObservableMetric {
|
|
}
|
|
exports.NoopObservableCounterMetric = NoopObservableCounterMetric;
|
|
|
|
class NoopObservableGaugeMetric extends NoopObservableMetric {
|
|
}
|
|
exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
|
|
|
|
class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
|
|
}
|
|
exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
|
|
exports.NOOP_METER = new NoopMeter;
|
|
exports.NOOP_COUNTER_METRIC = new NoopCounterMetric;
|
|
exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric;
|
|
exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric;
|
|
exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric;
|
|
exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric;
|
|
exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric;
|
|
exports.createNoopMeter = createNoopMeter;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/metrics/Metric.js
|
|
var require_Metric = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ValueType = undefined;
|
|
var ValueType;
|
|
(function(ValueType2) {
|
|
ValueType2[ValueType2["INT"] = 0] = "INT";
|
|
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
|
|
})(ValueType = exports.ValueType || (exports.ValueType = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
|
|
var require_TextMapPropagator = __commonJS((exports) => {
|
|
exports.defaultTextMapGetter = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.defaultTextMapSetter = exports.defaultTextMapGetter = undefined;
|
|
exports.defaultTextMapGetter = {
|
|
get(carrier, key) {
|
|
if (carrier == null)
|
|
return;
|
|
return carrier[key];
|
|
},
|
|
keys(carrier) {
|
|
if (carrier == null)
|
|
return [];
|
|
return Object.keys(carrier);
|
|
}
|
|
};
|
|
exports.defaultTextMapSetter = {
|
|
set(carrier, key, value) {
|
|
if (carrier == null)
|
|
return;
|
|
carrier[key] = value;
|
|
}
|
|
};
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
|
|
var require_NoopContextManager = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NoopContextManager = undefined;
|
|
var context_1 = require_context();
|
|
|
|
class NoopContextManager {
|
|
active() {
|
|
return context_1.ROOT_CONTEXT;
|
|
}
|
|
with(_context, fn, thisArg, ...args) {
|
|
return fn.call(thisArg, ...args);
|
|
}
|
|
bind(_context, target) {
|
|
return target;
|
|
}
|
|
enable() {
|
|
return this;
|
|
}
|
|
disable() {
|
|
return this;
|
|
}
|
|
}
|
|
exports.NoopContextManager = NoopContextManager;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/api/context.js
|
|
var require_context2 = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ContextAPI = undefined;
|
|
var NoopContextManager_1 = require_NoopContextManager();
|
|
var global_utils_1 = require_global_utils();
|
|
var diag_1 = require_diag();
|
|
var API_NAME = "context";
|
|
var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager;
|
|
|
|
class ContextAPI {
|
|
constructor() {
|
|
}
|
|
static getInstance() {
|
|
if (!this._instance)
|
|
this._instance = new ContextAPI;
|
|
return this._instance;
|
|
}
|
|
setGlobalContextManager(contextManager) {
|
|
return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
|
|
}
|
|
active() {
|
|
return this._getContextManager().active();
|
|
}
|
|
with(context, fn, thisArg, ...args) {
|
|
return this._getContextManager().with(context, fn, thisArg, ...args);
|
|
}
|
|
bind(context, target) {
|
|
return this._getContextManager().bind(context, target);
|
|
}
|
|
_getContextManager() {
|
|
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
|
|
}
|
|
disable() {
|
|
this._getContextManager().disable();
|
|
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
|
|
}
|
|
}
|
|
exports.ContextAPI = ContextAPI;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
|
|
var require_trace_flags = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.TraceFlags = undefined;
|
|
var TraceFlags;
|
|
(function(TraceFlags2) {
|
|
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
|
|
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
|
|
})(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
|
|
var require_invalid_span_constants = __commonJS((exports) => {
|
|
exports.INVALID_TRACEID = undefined;
|
|
exports.INVALID_SPANID = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = undefined;
|
|
var trace_flags_1 = require_trace_flags();
|
|
exports.INVALID_SPANID = "0000000000000000";
|
|
exports.INVALID_TRACEID = "00000000000000000000000000000000";
|
|
exports.INVALID_SPAN_CONTEXT = {
|
|
traceId: exports.INVALID_TRACEID,
|
|
spanId: exports.INVALID_SPANID,
|
|
traceFlags: trace_flags_1.TraceFlags.NONE
|
|
};
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
|
|
var require_NonRecordingSpan = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NonRecordingSpan = undefined;
|
|
var invalid_span_constants_1 = require_invalid_span_constants();
|
|
|
|
class NonRecordingSpan {
|
|
constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
|
|
this._spanContext = _spanContext;
|
|
}
|
|
spanContext() {
|
|
return this._spanContext;
|
|
}
|
|
setAttribute(_key, _value) {
|
|
return this;
|
|
}
|
|
setAttributes(_attributes) {
|
|
return this;
|
|
}
|
|
addEvent(_name, _attributes) {
|
|
return this;
|
|
}
|
|
setStatus(_status) {
|
|
return this;
|
|
}
|
|
updateName(_name) {
|
|
return this;
|
|
}
|
|
end(_endTime) {
|
|
}
|
|
isRecording() {
|
|
return false;
|
|
}
|
|
recordException(_exception, _time) {
|
|
}
|
|
}
|
|
exports.NonRecordingSpan = NonRecordingSpan;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/context-utils.js
|
|
var require_context_utils = __commonJS((exports) => {
|
|
var getSpan = function(context) {
|
|
return context.getValue(SPAN_KEY) || undefined;
|
|
};
|
|
var getActiveSpan = function() {
|
|
return getSpan(context_2.ContextAPI.getInstance().active());
|
|
};
|
|
var setSpan = function(context, span) {
|
|
return context.setValue(SPAN_KEY, span);
|
|
};
|
|
var deleteSpan = function(context) {
|
|
return context.deleteValue(SPAN_KEY);
|
|
};
|
|
var setSpanContext = function(context, spanContext) {
|
|
return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
|
|
};
|
|
var getSpanContext = function(context) {
|
|
var _a;
|
|
return (_a = getSpan(context)) === null || _a === undefined ? undefined : _a.spanContext();
|
|
};
|
|
exports.setSpanContext = undefined;
|
|
exports.deleteSpan = undefined;
|
|
exports.setSpan = undefined;
|
|
exports.getActiveSpan = undefined;
|
|
exports.getSpan = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = undefined;
|
|
var context_1 = require_context();
|
|
var NonRecordingSpan_1 = require_NonRecordingSpan();
|
|
var context_2 = require_context2();
|
|
var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
|
|
exports.getSpan = getSpan;
|
|
exports.getActiveSpan = getActiveSpan;
|
|
exports.setSpan = setSpan;
|
|
exports.deleteSpan = deleteSpan;
|
|
exports.setSpanContext = setSpanContext;
|
|
exports.getSpanContext = getSpanContext;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
|
|
var require_spancontext_utils = __commonJS((exports) => {
|
|
var isValidTraceId = function(traceId) {
|
|
return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
|
|
};
|
|
var isValidSpanId = function(spanId) {
|
|
return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
|
|
};
|
|
var isSpanContextValid = function(spanContext) {
|
|
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
|
|
};
|
|
var wrapSpanContext = function(spanContext) {
|
|
return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
|
|
};
|
|
exports.isSpanContextValid = undefined;
|
|
exports.isValidSpanId = undefined;
|
|
exports.isValidTraceId = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = undefined;
|
|
var invalid_span_constants_1 = require_invalid_span_constants();
|
|
var NonRecordingSpan_1 = require_NonRecordingSpan();
|
|
var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
|
|
var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
|
|
exports.isValidTraceId = isValidTraceId;
|
|
exports.isValidSpanId = isValidSpanId;
|
|
exports.isSpanContextValid = isSpanContextValid;
|
|
exports.wrapSpanContext = wrapSpanContext;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
|
|
var require_NoopTracer = __commonJS((exports) => {
|
|
var isSpanContext = function(spanContext) {
|
|
return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NoopTracer = undefined;
|
|
var context_1 = require_context2();
|
|
var context_utils_1 = require_context_utils();
|
|
var NonRecordingSpan_1 = require_NonRecordingSpan();
|
|
var spancontext_utils_1 = require_spancontext_utils();
|
|
var contextApi = context_1.ContextAPI.getInstance();
|
|
|
|
class NoopTracer {
|
|
startSpan(name, options, context = contextApi.active()) {
|
|
const root = Boolean(options === null || options === undefined ? undefined : options.root);
|
|
if (root)
|
|
return new NonRecordingSpan_1.NonRecordingSpan;
|
|
const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
|
|
if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext))
|
|
return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
|
|
else
|
|
return new NonRecordingSpan_1.NonRecordingSpan;
|
|
}
|
|
startActiveSpan(name, arg2, arg3, arg4) {
|
|
let opts;
|
|
let ctx;
|
|
let 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;
|
|
}
|
|
const parentContext = ctx !== null && ctx !== undefined ? ctx : contextApi.active();
|
|
const span = this.startSpan(name, opts, parentContext);
|
|
const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
|
|
return contextApi.with(contextWithSpanSet, fn, undefined, span);
|
|
}
|
|
}
|
|
exports.NoopTracer = NoopTracer;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
|
|
var require_ProxyTracer = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ProxyTracer = undefined;
|
|
var NoopTracer_1 = require_NoopTracer();
|
|
var NOOP_TRACER = new NoopTracer_1.NoopTracer;
|
|
|
|
class ProxyTracer {
|
|
constructor(_provider, name, version3, options) {
|
|
this._provider = _provider;
|
|
this.name = name;
|
|
this.version = version3;
|
|
this.options = options;
|
|
}
|
|
startSpan(name, options, context) {
|
|
return this._getTracer().startSpan(name, options, context);
|
|
}
|
|
startActiveSpan(_name, _options, _context, _fn) {
|
|
const tracer = this._getTracer();
|
|
return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
|
|
}
|
|
_getTracer() {
|
|
if (this._delegate)
|
|
return this._delegate;
|
|
const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
|
|
if (!tracer)
|
|
return NOOP_TRACER;
|
|
this._delegate = tracer;
|
|
return this._delegate;
|
|
}
|
|
}
|
|
exports.ProxyTracer = ProxyTracer;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
|
|
var require_NoopTracerProvider = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NoopTracerProvider = undefined;
|
|
var NoopTracer_1 = require_NoopTracer();
|
|
|
|
class NoopTracerProvider {
|
|
getTracer(_name, _version, _options) {
|
|
return new NoopTracer_1.NoopTracer;
|
|
}
|
|
}
|
|
exports.NoopTracerProvider = NoopTracerProvider;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
|
|
var require_ProxyTracerProvider = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.ProxyTracerProvider = undefined;
|
|
var ProxyTracer_1 = require_ProxyTracer();
|
|
var NoopTracerProvider_1 = require_NoopTracerProvider();
|
|
var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider;
|
|
|
|
class ProxyTracerProvider {
|
|
getTracer(name, version3, options) {
|
|
var _a;
|
|
return (_a = this.getDelegateTracer(name, version3, options)) !== null && _a !== undefined ? _a : new ProxyTracer_1.ProxyTracer(this, name, version3, options);
|
|
}
|
|
getDelegate() {
|
|
var _a;
|
|
return (_a = this._delegate) !== null && _a !== undefined ? _a : NOOP_TRACER_PROVIDER;
|
|
}
|
|
setDelegate(delegate) {
|
|
this._delegate = delegate;
|
|
}
|
|
getDelegateTracer(name, version3, options) {
|
|
var _a;
|
|
return (_a = this._delegate) === null || _a === undefined ? undefined : _a.getTracer(name, version3, options);
|
|
}
|
|
}
|
|
exports.ProxyTracerProvider = ProxyTracerProvider;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
|
|
var require_SamplingResult = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.SamplingDecision = undefined;
|
|
var SamplingDecision;
|
|
(function(SamplingDecision2) {
|
|
SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
|
|
SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
|
|
SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
|
|
})(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/span_kind.js
|
|
var require_span_kind = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.SpanKind = undefined;
|
|
var SpanKind;
|
|
(function(SpanKind2) {
|
|
SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
|
|
SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
|
|
SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
|
|
SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
|
|
SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
|
|
})(SpanKind = exports.SpanKind || (exports.SpanKind = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/status.js
|
|
var require_status = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.SpanStatusCode = undefined;
|
|
var SpanStatusCode;
|
|
(function(SpanStatusCode2) {
|
|
SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
|
|
SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
|
|
SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
|
|
})(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {}));
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
|
|
var require_tracestate_validators = __commonJS((exports) => {
|
|
var validateKey = function(key) {
|
|
return VALID_KEY_REGEX.test(key);
|
|
};
|
|
var validateValue = function(value) {
|
|
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
|
|
};
|
|
exports.validateKey = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.validateValue = exports.validateKey = undefined;
|
|
var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
|
|
var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
|
|
var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
|
|
var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})\$`);
|
|
var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
|
|
var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
|
|
exports.validateKey = validateKey;
|
|
exports.validateValue = validateValue;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
|
|
var require_tracestate_impl = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.TraceStateImpl = undefined;
|
|
var tracestate_validators_1 = require_tracestate_validators();
|
|
var MAX_TRACE_STATE_ITEMS = 32;
|
|
var MAX_TRACE_STATE_LEN = 512;
|
|
var LIST_MEMBERS_SEPARATOR = ",";
|
|
var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
|
|
|
|
class TraceStateImpl {
|
|
constructor(rawTraceState) {
|
|
this._internalState = new Map;
|
|
if (rawTraceState)
|
|
this._parse(rawTraceState);
|
|
}
|
|
set(key, value) {
|
|
const traceState = this._clone();
|
|
if (traceState._internalState.has(key))
|
|
traceState._internalState.delete(key);
|
|
traceState._internalState.set(key, value);
|
|
return traceState;
|
|
}
|
|
unset(key) {
|
|
const traceState = this._clone();
|
|
traceState._internalState.delete(key);
|
|
return traceState;
|
|
}
|
|
get(key) {
|
|
return this._internalState.get(key);
|
|
}
|
|
serialize() {
|
|
return this._keys().reduce((agg, key) => {
|
|
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
|
|
return agg;
|
|
}, []).join(LIST_MEMBERS_SEPARATOR);
|
|
}
|
|
_parse(rawTraceState) {
|
|
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
|
|
return;
|
|
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
|
|
const listMember = part.trim();
|
|
const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
|
|
if (i !== -1) {
|
|
const key = listMember.slice(0, i);
|
|
const value = listMember.slice(i + 1, part.length);
|
|
if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value))
|
|
agg.set(key, value);
|
|
}
|
|
return agg;
|
|
}, new Map);
|
|
if (this._internalState.size > MAX_TRACE_STATE_ITEMS)
|
|
this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
|
|
}
|
|
_keys() {
|
|
return Array.from(this._internalState.keys()).reverse();
|
|
}
|
|
_clone() {
|
|
const traceState = new TraceStateImpl;
|
|
traceState._internalState = new Map(this._internalState);
|
|
return traceState;
|
|
}
|
|
}
|
|
exports.TraceStateImpl = TraceStateImpl;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
|
|
var require_utils4 = __commonJS((exports) => {
|
|
var createTraceState = function(rawTraceState) {
|
|
return new tracestate_impl_1.TraceStateImpl(rawTraceState);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.createTraceState = undefined;
|
|
var tracestate_impl_1 = require_tracestate_impl();
|
|
exports.createTraceState = createTraceState;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/context-api.js
|
|
var require_context_api = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.context = undefined;
|
|
var context_1 = require_context2();
|
|
exports.context = context_1.ContextAPI.getInstance();
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/diag-api.js
|
|
var require_diag_api = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.diag = undefined;
|
|
var diag_1 = require_diag();
|
|
exports.diag = diag_1.DiagAPI.instance();
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
|
|
var require_NoopMeterProvider = __commonJS((exports) => {
|
|
exports.NoopMeterProvider = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = undefined;
|
|
var NoopMeter_1 = require_NoopMeter();
|
|
|
|
class NoopMeterProvider {
|
|
getMeter(_name, _version, _options) {
|
|
return NoopMeter_1.NOOP_METER;
|
|
}
|
|
}
|
|
exports.NoopMeterProvider = NoopMeterProvider;
|
|
exports.NOOP_METER_PROVIDER = new NoopMeterProvider;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/api/metrics.js
|
|
var require_metrics = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.MetricsAPI = undefined;
|
|
var NoopMeterProvider_1 = require_NoopMeterProvider();
|
|
var global_utils_1 = require_global_utils();
|
|
var diag_1 = require_diag();
|
|
var API_NAME = "metrics";
|
|
|
|
class MetricsAPI {
|
|
constructor() {
|
|
}
|
|
static getInstance() {
|
|
if (!this._instance)
|
|
this._instance = new MetricsAPI;
|
|
return this._instance;
|
|
}
|
|
setGlobalMeterProvider(provider) {
|
|
return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
|
|
}
|
|
getMeterProvider() {
|
|
return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
|
|
}
|
|
getMeter(name, version3, options) {
|
|
return this.getMeterProvider().getMeter(name, version3, options);
|
|
}
|
|
disable() {
|
|
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
|
|
}
|
|
}
|
|
exports.MetricsAPI = MetricsAPI;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/metrics-api.js
|
|
var require_metrics_api = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.metrics = undefined;
|
|
var metrics_1 = require_metrics();
|
|
exports.metrics = metrics_1.MetricsAPI.getInstance();
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
|
|
var require_NoopTextMapPropagator = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.NoopTextMapPropagator = undefined;
|
|
|
|
class NoopTextMapPropagator {
|
|
inject(_context, _carrier) {
|
|
}
|
|
extract(context, _carrier) {
|
|
return context;
|
|
}
|
|
fields() {
|
|
return [];
|
|
}
|
|
}
|
|
exports.NoopTextMapPropagator = NoopTextMapPropagator;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
|
|
var require_context_helpers = __commonJS((exports) => {
|
|
var getBaggage = function(context) {
|
|
return context.getValue(BAGGAGE_KEY) || undefined;
|
|
};
|
|
var getActiveBaggage = function() {
|
|
return getBaggage(context_1.ContextAPI.getInstance().active());
|
|
};
|
|
var setBaggage = function(context, baggage) {
|
|
return context.setValue(BAGGAGE_KEY, baggage);
|
|
};
|
|
var deleteBaggage = function(context) {
|
|
return context.deleteValue(BAGGAGE_KEY);
|
|
};
|
|
exports.setBaggage = undefined;
|
|
exports.getActiveBaggage = undefined;
|
|
exports.getBaggage = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = undefined;
|
|
var context_1 = require_context2();
|
|
var context_2 = require_context();
|
|
var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
|
|
exports.getBaggage = getBaggage;
|
|
exports.getActiveBaggage = getActiveBaggage;
|
|
exports.setBaggage = setBaggage;
|
|
exports.deleteBaggage = deleteBaggage;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/api/propagation.js
|
|
var require_propagation = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.PropagationAPI = undefined;
|
|
var global_utils_1 = require_global_utils();
|
|
var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
|
|
var TextMapPropagator_1 = require_TextMapPropagator();
|
|
var context_helpers_1 = require_context_helpers();
|
|
var utils_1 = require_utils3();
|
|
var diag_1 = require_diag();
|
|
var API_NAME = "propagation";
|
|
var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator;
|
|
|
|
class PropagationAPI {
|
|
constructor() {
|
|
this.createBaggage = utils_1.createBaggage;
|
|
this.getBaggage = context_helpers_1.getBaggage;
|
|
this.getActiveBaggage = context_helpers_1.getActiveBaggage;
|
|
this.setBaggage = context_helpers_1.setBaggage;
|
|
this.deleteBaggage = context_helpers_1.deleteBaggage;
|
|
}
|
|
static getInstance() {
|
|
if (!this._instance)
|
|
this._instance = new PropagationAPI;
|
|
return this._instance;
|
|
}
|
|
setGlobalPropagator(propagator) {
|
|
return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
|
|
}
|
|
inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
|
|
return this._getGlobalPropagator().inject(context, carrier, setter);
|
|
}
|
|
extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
|
|
return this._getGlobalPropagator().extract(context, carrier, getter);
|
|
}
|
|
fields() {
|
|
return this._getGlobalPropagator().fields();
|
|
}
|
|
disable() {
|
|
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
|
|
}
|
|
_getGlobalPropagator() {
|
|
return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
|
|
}
|
|
}
|
|
exports.PropagationAPI = PropagationAPI;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/propagation-api.js
|
|
var require_propagation_api = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.propagation = undefined;
|
|
var propagation_1 = require_propagation();
|
|
exports.propagation = propagation_1.PropagationAPI.getInstance();
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/api/trace.js
|
|
var require_trace = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.TraceAPI = undefined;
|
|
var global_utils_1 = require_global_utils();
|
|
var ProxyTracerProvider_1 = require_ProxyTracerProvider();
|
|
var spancontext_utils_1 = require_spancontext_utils();
|
|
var context_utils_1 = require_context_utils();
|
|
var diag_1 = require_diag();
|
|
var API_NAME = "trace";
|
|
|
|
class TraceAPI {
|
|
constructor() {
|
|
this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
|
|
this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
|
|
this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
|
|
this.deleteSpan = context_utils_1.deleteSpan;
|
|
this.getSpan = context_utils_1.getSpan;
|
|
this.getActiveSpan = context_utils_1.getActiveSpan;
|
|
this.getSpanContext = context_utils_1.getSpanContext;
|
|
this.setSpan = context_utils_1.setSpan;
|
|
this.setSpanContext = context_utils_1.setSpanContext;
|
|
}
|
|
static getInstance() {
|
|
if (!this._instance)
|
|
this._instance = new TraceAPI;
|
|
return this._instance;
|
|
}
|
|
setGlobalTracerProvider(provider) {
|
|
const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
|
|
if (success)
|
|
this._proxyTracerProvider.setDelegate(provider);
|
|
return success;
|
|
}
|
|
getTracerProvider() {
|
|
return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
|
|
}
|
|
getTracer(name, version3) {
|
|
return this.getTracerProvider().getTracer(name, version3);
|
|
}
|
|
disable() {
|
|
(0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
|
|
this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
|
|
}
|
|
}
|
|
exports.TraceAPI = TraceAPI;
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/trace-api.js
|
|
var require_trace_api = __commonJS((exports) => {
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.trace = undefined;
|
|
var trace_1 = require_trace();
|
|
exports.trace = trace_1.TraceAPI.getInstance();
|
|
});
|
|
|
|
// node_modules/@opentelemetry/api/build/src/index.js
|
|
var require_src = __commonJS((exports) => {
|
|
exports.propagation = undefined;
|
|
exports.metrics = undefined;
|
|
exports.diag = undefined;
|
|
exports.context = undefined;
|
|
exports.INVALID_SPAN_CONTEXT = undefined;
|
|
exports.INVALID_TRACEID = undefined;
|
|
exports.INVALID_SPANID = undefined;
|
|
exports.isValidSpanId = undefined;
|
|
exports.isValidTraceId = undefined;
|
|
exports.isSpanContextValid = undefined;
|
|
exports.createTraceState = undefined;
|
|
exports.TraceFlags = undefined;
|
|
exports.SpanStatusCode = undefined;
|
|
exports.SpanKind = undefined;
|
|
exports.SamplingDecision = undefined;
|
|
exports.ProxyTracerProvider = undefined;
|
|
exports.ProxyTracer = undefined;
|
|
exports.defaultTextMapSetter = undefined;
|
|
exports.defaultTextMapGetter = undefined;
|
|
exports.ValueType = undefined;
|
|
exports.createNoopMeter = undefined;
|
|
exports.DiagLogLevel = undefined;
|
|
exports.DiagConsoleLogger = undefined;
|
|
exports.ROOT_CONTEXT = undefined;
|
|
exports.createContextKey = undefined;
|
|
exports.baggageEntryMetadataFromString = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = undefined;
|
|
var utils_1 = require_utils3();
|
|
Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
|
|
return utils_1.baggageEntryMetadataFromString;
|
|
} });
|
|
var context_1 = require_context();
|
|
Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function() {
|
|
return context_1.createContextKey;
|
|
} });
|
|
Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function() {
|
|
return context_1.ROOT_CONTEXT;
|
|
} });
|
|
var consoleLogger_1 = require_consoleLogger();
|
|
Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function() {
|
|
return consoleLogger_1.DiagConsoleLogger;
|
|
} });
|
|
var types_1 = require_types();
|
|
Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function() {
|
|
return types_1.DiagLogLevel;
|
|
} });
|
|
var NoopMeter_1 = require_NoopMeter();
|
|
Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function() {
|
|
return NoopMeter_1.createNoopMeter;
|
|
} });
|
|
var Metric_1 = require_Metric();
|
|
Object.defineProperty(exports, "ValueType", { enumerable: true, get: function() {
|
|
return Metric_1.ValueType;
|
|
} });
|
|
var TextMapPropagator_1 = require_TextMapPropagator();
|
|
Object.defineProperty(exports, "defaultTextMapGetter", { enumerable: true, get: function() {
|
|
return TextMapPropagator_1.defaultTextMapGetter;
|
|
} });
|
|
Object.defineProperty(exports, "defaultTextMapSetter", { enumerable: true, get: function() {
|
|
return TextMapPropagator_1.defaultTextMapSetter;
|
|
} });
|
|
var ProxyTracer_1 = require_ProxyTracer();
|
|
Object.defineProperty(exports, "ProxyTracer", { enumerable: true, get: function() {
|
|
return ProxyTracer_1.ProxyTracer;
|
|
} });
|
|
var ProxyTracerProvider_1 = require_ProxyTracerProvider();
|
|
Object.defineProperty(exports, "ProxyTracerProvider", { enumerable: true, get: function() {
|
|
return ProxyTracerProvider_1.ProxyTracerProvider;
|
|
} });
|
|
var SamplingResult_1 = require_SamplingResult();
|
|
Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
|
|
return SamplingResult_1.SamplingDecision;
|
|
} });
|
|
var span_kind_1 = require_span_kind();
|
|
Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function() {
|
|
return span_kind_1.SpanKind;
|
|
} });
|
|
var status_1 = require_status();
|
|
Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function() {
|
|
return status_1.SpanStatusCode;
|
|
} });
|
|
var trace_flags_1 = require_trace_flags();
|
|
Object.defineProperty(exports, "TraceFlags", { enumerable: true, get: function() {
|
|
return trace_flags_1.TraceFlags;
|
|
} });
|
|
var utils_2 = require_utils4();
|
|
Object.defineProperty(exports, "createTraceState", { enumerable: true, get: function() {
|
|
return utils_2.createTraceState;
|
|
} });
|
|
var spancontext_utils_1 = require_spancontext_utils();
|
|
Object.defineProperty(exports, "isSpanContextValid", { enumerable: true, get: function() {
|
|
return spancontext_utils_1.isSpanContextValid;
|
|
} });
|
|
Object.defineProperty(exports, "isValidTraceId", { enumerable: true, get: function() {
|
|
return spancontext_utils_1.isValidTraceId;
|
|
} });
|
|
Object.defineProperty(exports, "isValidSpanId", { enumerable: true, get: function() {
|
|
return spancontext_utils_1.isValidSpanId;
|
|
} });
|
|
var invalid_span_constants_1 = require_invalid_span_constants();
|
|
Object.defineProperty(exports, "INVALID_SPANID", { enumerable: true, get: function() {
|
|
return invalid_span_constants_1.INVALID_SPANID;
|
|
} });
|
|
Object.defineProperty(exports, "INVALID_TRACEID", { enumerable: true, get: function() {
|
|
return invalid_span_constants_1.INVALID_TRACEID;
|
|
} });
|
|
Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function() {
|
|
return invalid_span_constants_1.INVALID_SPAN_CONTEXT;
|
|
} });
|
|
var context_api_1 = require_context_api();
|
|
Object.defineProperty(exports, "context", { enumerable: true, get: function() {
|
|
return context_api_1.context;
|
|
} });
|
|
var diag_api_1 = require_diag_api();
|
|
Object.defineProperty(exports, "diag", { enumerable: true, get: function() {
|
|
return diag_api_1.diag;
|
|
} });
|
|
var metrics_api_1 = require_metrics_api();
|
|
Object.defineProperty(exports, "metrics", { enumerable: true, get: function() {
|
|
return metrics_api_1.metrics;
|
|
} });
|
|
var propagation_api_1 = require_propagation_api();
|
|
Object.defineProperty(exports, "propagation", { enumerable: true, get: function() {
|
|
return propagation_api_1.propagation;
|
|
} });
|
|
var trace_api_1 = require_trace_api();
|
|
Object.defineProperty(exports, "trace", { enumerable: true, get: function() {
|
|
return trace_api_1.trace;
|
|
} });
|
|
exports.default = {
|
|
context: context_api_1.context,
|
|
diag: diag_api_1.diag,
|
|
metrics: metrics_api_1.metrics,
|
|
propagation: propagation_api_1.propagation,
|
|
trace: trace_api_1.trace
|
|
};
|
|
});
|
|
|
|
// node_modules/@azure/core-tracing/dist/index.js
|
|
var require_dist5 = __commonJS((exports) => {
|
|
var getSpan = function(context2) {
|
|
return api.trace.getSpan(context2);
|
|
};
|
|
var setSpan = function(context2, span) {
|
|
return api.trace.setSpan(context2, span);
|
|
};
|
|
var setSpanContext = function(context2, spanContext) {
|
|
return api.trace.setSpanContext(context2, spanContext);
|
|
};
|
|
var getSpanContext = function(context2) {
|
|
return api.trace.getSpanContext(context2);
|
|
};
|
|
var isSpanContextValid = function(context2) {
|
|
return api.trace.isSpanContextValid(context2);
|
|
};
|
|
var getTracer = function(name, version3) {
|
|
return api.trace.getTracer(name || "azure/core-tracing", version3);
|
|
};
|
|
var isTracingDisabled = function() {
|
|
var _a;
|
|
if (typeof process === "undefined")
|
|
return false;
|
|
const azureTracingDisabledValue = (_a = process.env.AZURE_TRACING_DISABLED) === null || _a === undefined ? undefined : _a.toLowerCase();
|
|
if (azureTracingDisabledValue === "false" || azureTracingDisabledValue === "0")
|
|
return false;
|
|
return Boolean(azureTracingDisabledValue);
|
|
};
|
|
var createSpanFunction = function(args) {
|
|
return function(operationName, operationOptions) {
|
|
const tracer = getTracer();
|
|
const tracingOptions = (operationOptions === null || operationOptions === undefined ? undefined : 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
|
|
};
|
|
};
|
|
};
|
|
var extractSpanContextFromTraceParentHeader = function(traceParentHeader) {
|
|
const parts = traceParentHeader.split("-");
|
|
if (parts.length !== 4)
|
|
return;
|
|
const [version3, traceId, spanId, traceOptions] = parts;
|
|
if (version3 !== VERSION)
|
|
return;
|
|
const traceFlags = parseInt(traceOptions, 16);
|
|
const spanContext = {
|
|
spanId,
|
|
traceId,
|
|
traceFlags
|
|
};
|
|
return spanContext;
|
|
};
|
|
var getTraceParentHeader = function(spanContext) {
|
|
const missingFields = [];
|
|
if (!spanContext.traceId)
|
|
missingFields.push("traceId");
|
|
if (!spanContext.spanId)
|
|
missingFields.push("spanId");
|
|
if (missingFields.length)
|
|
return;
|
|
const flags = spanContext.traceFlags || 0;
|
|
const hexFlags = flags.toString(16);
|
|
const traceFlags = hexFlags.length === 1 ? `0${hexFlags}` : hexFlags;
|
|
return `${VERSION}-${spanContext.traceId}-${spanContext.spanId}-${traceFlags}`;
|
|
};
|
|
exports.SpanKind = undefined;
|
|
exports.SpanStatusCode = undefined;
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var api = require_src();
|
|
(function(SpanKind) {
|
|
SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
|
|
SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
|
|
SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
|
|
SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
|
|
SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
|
|
})(exports.SpanKind || (exports.SpanKind = {}));
|
|
var context = api.context;
|
|
(function(SpanStatusCode) {
|
|
SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
|
|
SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
|
|
SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
|
|
})(exports.SpanStatusCode || (exports.SpanStatusCode = {}));
|
|
var VERSION = "00";
|
|
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;
|
|
});
|
|
|
|
// node_modules/@azure/core-http/dist/index.js
|
|
var require_dist6 = __commonJS((exports) => {
|
|
var _interopDefaultLegacy = function(e) {
|
|
return e && typeof e === "object" && ("default" in e) ? e : { default: e };
|
|
};
|
|
var _interopNamespace = function(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 getHeaderKey = function(headerName) {
|
|
return headerName.toLowerCase();
|
|
};
|
|
var isHttpHeadersLike = function(object) {
|
|
if (object && typeof object === "object") {
|
|
const castObject = object;
|
|
if (typeof castObject.rawHeaders === "function" && typeof castObject.clone === "function" && typeof castObject.get === "function" && typeof castObject.set === "function" && typeof castObject.contains === "function" && typeof castObject.remove === "function" && typeof castObject.headersArray === "function" && typeof castObject.headerValues === "function" && typeof castObject.headerNames === "function" && typeof castObject.toJson === "function")
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
var encodeString = function(value) {
|
|
return Buffer.from(value).toString("base64");
|
|
};
|
|
var encodeByteArray = function(value) {
|
|
const bufferValue = value instanceof Buffer ? value : Buffer.from(value.buffer);
|
|
return bufferValue.toString("base64");
|
|
};
|
|
var decodeString = function(value) {
|
|
return Buffer.from(value, "base64");
|
|
};
|
|
var encodeUri = function(uri) {
|
|
return encodeURIComponent(uri).replace(/!/g, "%21").replace(/"/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/\*/g, "%2A");
|
|
};
|
|
var stripResponse = function(response) {
|
|
const strippedResponse = {};
|
|
strippedResponse.body = response.bodyAsText;
|
|
strippedResponse.headers = response.headers;
|
|
strippedResponse.status = response.status;
|
|
return strippedResponse;
|
|
};
|
|
var stripRequest = function(request) {
|
|
const strippedRequest = request.clone();
|
|
if (strippedRequest.headers)
|
|
strippedRequest.headers.remove("authorization");
|
|
return strippedRequest;
|
|
};
|
|
var isValidUuid = function(uuid2) {
|
|
return validUuidRegex.test(uuid2);
|
|
};
|
|
var generateUuid = function() {
|
|
return uuid.v4();
|
|
};
|
|
var executePromisesSequentially = function(promiseFactories, kickstart) {
|
|
let result = Promise.resolve(kickstart);
|
|
promiseFactories.forEach((promiseFactory) => {
|
|
result = result.then(promiseFactory);
|
|
});
|
|
return result;
|
|
};
|
|
var promiseToCallback = function(promise) {
|
|
if (typeof promise.then !== "function")
|
|
throw new Error("The provided input is not a Promise.");
|
|
return (cb) => {
|
|
promise.then((data) => {
|
|
return cb(undefined, data);
|
|
}).catch((err) => {
|
|
cb(err);
|
|
});
|
|
};
|
|
};
|
|
var promiseToServiceCallback = function(promise) {
|
|
if (typeof promise.then !== "function")
|
|
throw new Error("The provided input is not a Promise.");
|
|
return (cb) => {
|
|
promise.then((data) => {
|
|
return process.nextTick(cb, undefined, data.parsedBody, data.request, data);
|
|
}).catch((err) => {
|
|
process.nextTick(cb, err);
|
|
});
|
|
};
|
|
};
|
|
var prepareXMLRootList = function(obj, elementName, xmlNamespaceKey, xmlNamespace) {
|
|
if (!Array.isArray(obj))
|
|
obj = [obj];
|
|
if (!xmlNamespaceKey || !xmlNamespace)
|
|
return { [elementName]: obj };
|
|
const result = { [elementName]: obj };
|
|
result[XML_ATTRKEY] = { [xmlNamespaceKey]: xmlNamespace };
|
|
return result;
|
|
};
|
|
var applyMixins = function(targetCtorParam, sourceCtors) {
|
|
const castTargetCtorParam = targetCtorParam;
|
|
sourceCtors.forEach((sourceCtor) => {
|
|
Object.getOwnPropertyNames(sourceCtor.prototype).forEach((name) => {
|
|
castTargetCtorParam.prototype[name] = sourceCtor.prototype[name];
|
|
});
|
|
});
|
|
};
|
|
var isDuration = function(value) {
|
|
return validateISODuration.test(value);
|
|
};
|
|
var replaceAll = function(value, searchValue, replaceValue) {
|
|
return !value || !searchValue ? value : value.split(searchValue).join(replaceValue || "");
|
|
};
|
|
var isPrimitiveType = function(value) {
|
|
return typeof value !== "object" && typeof value !== "function" || value === null;
|
|
};
|
|
var getEnvironmentValue = function(name) {
|
|
if (process.env[name])
|
|
return process.env[name];
|
|
else if (process.env[name.toLowerCase()])
|
|
return process.env[name.toLowerCase()];
|
|
return;
|
|
};
|
|
var isObject = function(input) {
|
|
return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof RegExp) && !(input instanceof Date);
|
|
};
|
|
var trimEnd = function(str, ch) {
|
|
let len = str.length;
|
|
while (len - 1 >= 0 && str[len - 1] === ch)
|
|
--len;
|
|
return str.substr(0, len);
|
|
};
|
|
var bufferToBase64Url = function(buffer) {
|
|
if (!buffer)
|
|
return;
|
|
if (!(buffer instanceof Uint8Array))
|
|
throw new Error(`Please provide an input of type Uint8Array for converting to Base64Url.`);
|
|
const str = encodeByteArray(buffer);
|
|
return trimEnd(str, "=").replace(/\+/g, "-").replace(/\//g, "_");
|
|
};
|
|
var base64UrlToByteArray = function(str) {
|
|
if (!str)
|
|
return;
|
|
if (str && typeof str.valueOf() !== "string")
|
|
throw new Error("Please provide an input of type string for converting to Uint8Array");
|
|
str = str.replace(/-/g, "+").replace(/_/g, "/");
|
|
return decodeString(str);
|
|
};
|
|
var splitSerializeName = function(prop) {
|
|
const classes = [];
|
|
let partialclass = "";
|
|
if (prop) {
|
|
const subwords = prop.split(".");
|
|
for (const item of subwords)
|
|
if (item.charAt(item.length - 1) === "\\")
|
|
partialclass += item.substr(0, item.length - 1) + ".";
|
|
else {
|
|
partialclass += item;
|
|
classes.push(partialclass);
|
|
partialclass = "";
|
|
}
|
|
}
|
|
return classes;
|
|
};
|
|
var dateToUnixTime = function(d) {
|
|
if (!d)
|
|
return;
|
|
if (typeof d.valueOf() === "string")
|
|
d = new Date(d);
|
|
return Math.floor(d.getTime() / 1000);
|
|
};
|
|
var unixTimeToDate = function(n) {
|
|
if (!n)
|
|
return;
|
|
return new Date(n * 1000);
|
|
};
|
|
var serializeBasicTypes = function(typeName, objectName, value) {
|
|
if (value !== null && value !== undefined) {
|
|
if (typeName.match(/^Number$/i) !== null) {
|
|
if (typeof value !== "number")
|
|
throw new Error(`${objectName} with value ${value} must be of type number.`);
|
|
} else if (typeName.match(/^String$/i) !== null) {
|
|
if (typeof value.valueOf() !== "string")
|
|
throw new Error(`${objectName} with value "${value}" must be of type string.`);
|
|
} else if (typeName.match(/^Uuid$/i) !== null) {
|
|
if (!(typeof value.valueOf() === "string" && isValidUuid(value)))
|
|
throw new Error(`${objectName} with value "${value}" must be of type string and a valid uuid.`);
|
|
} else if (typeName.match(/^Boolean$/i) !== null) {
|
|
if (typeof value !== "boolean")
|
|
throw new Error(`${objectName} with value ${value} must be of type boolean.`);
|
|
} else if (typeName.match(/^Stream$/i) !== null) {
|
|
const objectType = typeof value;
|
|
if (objectType !== "string" && objectType !== "function" && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value) && !((typeof Blob === "function" || typeof Blob === "object") && value instanceof Blob))
|
|
throw new Error(`${objectName} must be a string, Blob, ArrayBuffer, ArrayBufferView, or a function returning NodeJS.ReadableStream.`);
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
var serializeEnumType = function(objectName, allowedValues, value) {
|
|
if (!allowedValues)
|
|
throw new Error(`Please provide a set of allowedValues to validate ${objectName} as an Enum Type.`);
|
|
const isPresent = allowedValues.some((item) => {
|
|
if (typeof item.valueOf() === "string")
|
|
return item.toLowerCase() === value.toLowerCase();
|
|
return item === value;
|
|
});
|
|
if (!isPresent)
|
|
throw new Error(`${value} is not a valid value for ${objectName}. The valid values are: ${JSON.stringify(allowedValues)}.`);
|
|
return value;
|
|
};
|
|
var serializeByteArrayType = function(objectName, value) {
|
|
let returnValue = "";
|
|
if (value != null) {
|
|
if (!(value instanceof Uint8Array))
|
|
throw new Error(`${objectName} must be of type Uint8Array.`);
|
|
returnValue = encodeByteArray(value);
|
|
}
|
|
return returnValue;
|
|
};
|
|
var serializeBase64UrlType = function(objectName, value) {
|
|
let returnValue = "";
|
|
if (value != null) {
|
|
if (!(value instanceof Uint8Array))
|
|
throw new Error(`${objectName} must be of type Uint8Array.`);
|
|
returnValue = bufferToBase64Url(value) || "";
|
|
}
|
|
return returnValue;
|
|
};
|
|
var serializeDateTypes = function(typeName, value, objectName) {
|
|
if (value != null) {
|
|
if (typeName.match(/^Date$/i) !== null) {
|
|
if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))
|
|
throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);
|
|
value = value instanceof Date ? value.toISOString().substring(0, 10) : new Date(value).toISOString().substring(0, 10);
|
|
} else if (typeName.match(/^DateTime$/i) !== null) {
|
|
if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))
|
|
throw new Error(`${objectName} must be an instanceof Date or a string in ISO8601 format.`);
|
|
value = value instanceof Date ? value.toISOString() : new Date(value).toISOString();
|
|
} else if (typeName.match(/^DateTimeRfc1123$/i) !== null) {
|
|
if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))
|
|
throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123 format.`);
|
|
value = value instanceof Date ? value.toUTCString() : new Date(value).toUTCString();
|
|
} else if (typeName.match(/^UnixTime$/i) !== null) {
|
|
if (!(value instanceof Date || typeof value.valueOf() === "string" && !isNaN(Date.parse(value))))
|
|
throw new Error(`${objectName} must be an instanceof Date or a string in RFC-1123/ISO8601 format ` + `for it to be serialized in UnixTime/Epoch format.`);
|
|
value = dateToUnixTime(value);
|
|
} else if (typeName.match(/^TimeSpan$/i) !== null) {
|
|
if (!isDuration(value))
|
|
throw new Error(`${objectName} must be a string in ISO 8601 format. Instead was "${value}".`);
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
var serializeSequenceType = function(serializer, mapper, object, objectName, isXml, options) {
|
|
if (!Array.isArray(object))
|
|
throw new Error(`${objectName} must be of type Array.`);
|
|
const elementType = mapper.type.element;
|
|
if (!elementType || typeof elementType !== "object")
|
|
throw new Error(`element" metadata for an Array must be defined in the ` + `mapper and it must of type "object" in ${objectName}.`);
|
|
const tempArray = [];
|
|
for (let i = 0;i < object.length; i++) {
|
|
const serializedValue = serializer.serialize(elementType, object[i], objectName, options);
|
|
if (isXml && elementType.xmlNamespace) {
|
|
const xmlnsKey = elementType.xmlNamespacePrefix ? `xmlns:${elementType.xmlNamespacePrefix}` : "xmlns";
|
|
if (elementType.type.name === "Composite") {
|
|
tempArray[i] = Object.assign({}, serializedValue);
|
|
tempArray[i][XML_ATTRKEY] = { [xmlnsKey]: elementType.xmlNamespace };
|
|
} else {
|
|
tempArray[i] = {};
|
|
tempArray[i][options.xmlCharKey] = serializedValue;
|
|
tempArray[i][XML_ATTRKEY] = { [xmlnsKey]: elementType.xmlNamespace };
|
|
}
|
|
} else
|
|
tempArray[i] = serializedValue;
|
|
}
|
|
return tempArray;
|
|
};
|
|
var serializeDictionaryType = function(serializer, mapper, object, objectName, isXml, options) {
|
|
if (typeof object !== "object")
|
|
throw new Error(`${objectName} must be of type object.`);
|
|
const valueType = mapper.type.value;
|
|
if (!valueType || typeof valueType !== "object")
|
|
throw new Error(`"value" metadata for a Dictionary must be defined in the ` + `mapper and it must of type "object" in ${objectName}.`);
|
|
const tempDictionary = {};
|
|
for (const key of Object.keys(object)) {
|
|
const serializedValue = serializer.serialize(valueType, object[key], objectName, options);
|
|
tempDictionary[key] = getXmlObjectValue(valueType, serializedValue, isXml, options);
|
|
}
|
|
if (isXml && mapper.xmlNamespace) {
|
|
const xmlnsKey = mapper.xmlNamespacePrefix ? `xmlns:${mapper.xmlNamespacePrefix}` : "xmlns";
|
|
const result = tempDictionary;
|
|
result[XML_ATTRKEY] = { [xmlnsKey]: mapper.xmlNamespace };
|
|
return result;
|
|
}
|
|
return tempDictionary;
|
|
};
|
|
var resolveAdditionalProperties = function(serializer, mapper, objectName) {
|
|
const additionalProperties = mapper.type.additionalProperties;
|
|
if (!additionalProperties && mapper.type.className) {
|
|
const modelMapper = resolveReferencedMapper(serializer, mapper, objectName);
|
|
return modelMapper === null || modelMapper === undefined ? undefined : modelMapper.type.additionalProperties;
|
|
}
|
|
return additionalProperties;
|
|
};
|
|
var resolveReferencedMapper = function(serializer, mapper, objectName) {
|
|
const className = mapper.type.className;
|
|
if (!className)
|
|
throw new Error(`Class name for model "${objectName}" is not provided in the mapper "${JSON.stringify(mapper, undefined, 2)}".`);
|
|
return serializer.modelMappers[className];
|
|
};
|
|
var resolveModelProperties = function(serializer, mapper, objectName) {
|
|
let modelProps = mapper.type.modelProperties;
|
|
if (!modelProps) {
|
|
const modelMapper = resolveReferencedMapper(serializer, mapper, objectName);
|
|
if (!modelMapper)
|
|
throw new Error(`mapper() cannot be null or undefined for model "${mapper.type.className}".`);
|
|
modelProps = modelMapper === null || modelMapper === undefined ? undefined : modelMapper.type.modelProperties;
|
|
if (!modelProps)
|
|
throw new Error(`modelProperties cannot be null or undefined in the ` + `mapper "${JSON.stringify(modelMapper)}" of type "${mapper.type.className}" for object "${objectName}".`);
|
|
}
|
|
return modelProps;
|
|
};
|
|
var serializeCompositeType = function(serializer, mapper, object, objectName, isXml, options) {
|
|
if (getPolymorphicDiscriminatorRecursively(serializer, mapper))
|
|
mapper = getPolymorphicMapper(serializer, mapper, object, "clientName");
|
|
if (object != null) {
|
|
const payload = {};
|
|
const modelProps = resolveModelProperties(serializer, mapper, objectName);
|
|
for (const key of Object.keys(modelProps)) {
|
|
const propertyMapper = modelProps[key];
|
|
if (propertyMapper.readOnly)
|
|
continue;
|
|
let propName;
|
|
let parentObject = payload;
|
|
if (serializer.isXML)
|
|
if (propertyMapper.xmlIsWrapped)
|
|
propName = propertyMapper.xmlName;
|
|
else
|
|
propName = propertyMapper.xmlElementName || propertyMapper.xmlName;
|
|
else {
|
|
const paths = splitSerializeName(propertyMapper.serializedName);
|
|
propName = paths.pop();
|
|
for (const pathName of paths) {
|
|
const childObject = parentObject[pathName];
|
|
if (childObject == undefined && (object[key] != null || propertyMapper.defaultValue !== undefined))
|
|
parentObject[pathName] = {};
|
|
parentObject = parentObject[pathName];
|
|
}
|
|
}
|
|
if (parentObject != null) {
|
|
if (isXml && mapper.xmlNamespace) {
|
|
const xmlnsKey = mapper.xmlNamespacePrefix ? `xmlns:${mapper.xmlNamespacePrefix}` : "xmlns";
|
|
parentObject[XML_ATTRKEY] = Object.assign(Object.assign({}, parentObject[XML_ATTRKEY]), { [xmlnsKey]: mapper.xmlNamespace });
|
|
}
|
|
const propertyObjectName = propertyMapper.serializedName !== "" ? objectName + "." + propertyMapper.serializedName : objectName;
|
|
let toSerialize = object[key];
|
|
const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
|
|
if (polymorphicDiscriminator && polymorphicDiscriminator.clientName === key && toSerialize == undefined)
|
|
toSerialize = mapper.serializedName;
|
|
const serializedValue = serializer.serialize(propertyMapper, toSerialize, propertyObjectName, options);
|
|
if (serializedValue !== undefined && propName != null) {
|
|
const value = getXmlObjectValue(propertyMapper, serializedValue, isXml, options);
|
|
if (isXml && propertyMapper.xmlIsAttribute) {
|
|
parentObject[XML_ATTRKEY] = parentObject[XML_ATTRKEY] || {};
|
|
parentObject[XML_ATTRKEY][propName] = serializedValue;
|
|
} else if (isXml && propertyMapper.xmlIsWrapped)
|
|
parentObject[propName] = { [propertyMapper.xmlElementName]: value };
|
|
else
|
|
parentObject[propName] = value;
|
|
}
|
|
}
|
|
}
|
|
const additionalPropertiesMapper = resolveAdditionalProperties(serializer, mapper, objectName);
|
|
if (additionalPropertiesMapper) {
|
|
const propNames = Object.keys(modelProps);
|
|
for (const clientPropName in object) {
|
|
const isAdditionalProperty = propNames.every((pn) => pn !== clientPropName);
|
|
if (isAdditionalProperty)
|
|
payload[clientPropName] = serializer.serialize(additionalPropertiesMapper, object[clientPropName], objectName + '["' + clientPropName + '"]', options);
|
|
}
|
|
}
|
|
return payload;
|
|
}
|
|
return object;
|
|
};
|
|
var getXmlObjectValue = function(propertyMapper, serializedValue, isXml, options) {
|
|
if (!isXml || !propertyMapper.xmlNamespace)
|
|
return serializedValue;
|
|
const xmlnsKey = propertyMapper.xmlNamespacePrefix ? `xmlns:${propertyMapper.xmlNamespacePrefix}` : "xmlns";
|
|
const xmlNamespace = { [xmlnsKey]: propertyMapper.xmlNamespace };
|
|
if (["Composite"].includes(propertyMapper.type.name))
|
|
if (serializedValue[XML_ATTRKEY])
|
|
return serializedValue;
|
|
else {
|
|
const result2 = Object.assign({}, serializedValue);
|
|
result2[XML_ATTRKEY] = xmlNamespace;
|
|
return result2;
|
|
}
|
|
const result = {};
|
|
result[options.xmlCharKey] = serializedValue;
|
|
result[XML_ATTRKEY] = xmlNamespace;
|
|
return result;
|
|
};
|
|
var isSpecialXmlProperty = function(propertyName, options) {
|
|
return [XML_ATTRKEY, options.xmlCharKey].includes(propertyName);
|
|
};
|
|
var deserializeCompositeType = function(serializer, mapper, responseBody, objectName, options) {
|
|
var _a, _b;
|
|
const xmlCharKey = (_a = options.xmlCharKey) !== null && _a !== undefined ? _a : XML_CHARKEY;
|
|
if (getPolymorphicDiscriminatorRecursively(serializer, mapper))
|
|
mapper = getPolymorphicMapper(serializer, mapper, responseBody, "serializedName");
|
|
const modelProps = resolveModelProperties(serializer, mapper, objectName);
|
|
let instance = {};
|
|
const handledPropertyNames = [];
|
|
for (const key of Object.keys(modelProps)) {
|
|
const propertyMapper = modelProps[key];
|
|
const paths = splitSerializeName(modelProps[key].serializedName);
|
|
handledPropertyNames.push(paths[0]);
|
|
const { serializedName, xmlName, xmlElementName } = propertyMapper;
|
|
let propertyObjectName = objectName;
|
|
if (serializedName !== "" && serializedName !== undefined)
|
|
propertyObjectName = objectName + "." + serializedName;
|
|
const headerCollectionPrefix = propertyMapper.headerCollectionPrefix;
|
|
if (headerCollectionPrefix) {
|
|
const dictionary = {};
|
|
for (const headerKey of Object.keys(responseBody)) {
|
|
if (headerKey.startsWith(headerCollectionPrefix))
|
|
dictionary[headerKey.substring(headerCollectionPrefix.length)] = serializer.deserialize(propertyMapper.type.value, responseBody[headerKey], propertyObjectName, options);
|
|
handledPropertyNames.push(headerKey);
|
|
}
|
|
instance[key] = dictionary;
|
|
} else if (serializer.isXML)
|
|
if (propertyMapper.xmlIsAttribute && responseBody[XML_ATTRKEY])
|
|
instance[key] = serializer.deserialize(propertyMapper, responseBody[XML_ATTRKEY][xmlName], propertyObjectName, options);
|
|
else if (propertyMapper.xmlIsMsText) {
|
|
if (responseBody[xmlCharKey] !== undefined)
|
|
instance[key] = responseBody[xmlCharKey];
|
|
else if (typeof responseBody === "string")
|
|
instance[key] = responseBody;
|
|
} else {
|
|
const propertyName = xmlElementName || xmlName || serializedName;
|
|
if (propertyMapper.xmlIsWrapped) {
|
|
const wrapped = responseBody[xmlName];
|
|
const elementList = (_b = wrapped === null || wrapped === undefined ? undefined : wrapped[xmlElementName]) !== null && _b !== undefined ? _b : [];
|
|
instance[key] = serializer.deserialize(propertyMapper, elementList, propertyObjectName, options);
|
|
handledPropertyNames.push(xmlName);
|
|
} else {
|
|
const property = responseBody[propertyName];
|
|
instance[key] = serializer.deserialize(propertyMapper, property, propertyObjectName, options);
|
|
handledPropertyNames.push(propertyName);
|
|
}
|
|
}
|
|
else {
|
|
let propertyInstance;
|
|
let res = responseBody;
|
|
for (const item of paths) {
|
|
if (!res)
|
|
break;
|
|
res = res[item];
|
|
}
|
|
propertyInstance = res;
|
|
const polymorphicDiscriminator = mapper.type.polymorphicDiscriminator;
|
|
if (polymorphicDiscriminator && key === polymorphicDiscriminator.clientName && propertyInstance == undefined)
|
|
propertyInstance = mapper.serializedName;
|
|
let serializedValue;
|
|
if (Array.isArray(responseBody[key]) && modelProps[key].serializedName === "") {
|
|
propertyInstance = responseBody[key];
|
|
const arrayInstance = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);
|
|
for (const [k, v] of Object.entries(instance))
|
|
if (!Object.prototype.hasOwnProperty.call(arrayInstance, k))
|
|
arrayInstance[k] = v;
|
|
instance = arrayInstance;
|
|
} else if (propertyInstance !== undefined || propertyMapper.defaultValue !== undefined) {
|
|
serializedValue = serializer.deserialize(propertyMapper, propertyInstance, propertyObjectName, options);
|
|
instance[key] = serializedValue;
|
|
}
|
|
}
|
|
}
|
|
const additionalPropertiesMapper = mapper.type.additionalProperties;
|
|
if (additionalPropertiesMapper) {
|
|
const isAdditionalProperty = (responsePropName) => {
|
|
for (const clientPropName in modelProps) {
|
|
const paths = splitSerializeName(modelProps[clientPropName].serializedName);
|
|
if (paths[0] === responsePropName)
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
for (const responsePropName in responseBody)
|
|
if (isAdditionalProperty(responsePropName))
|
|
instance[responsePropName] = serializer.deserialize(additionalPropertiesMapper, responseBody[responsePropName], objectName + '["' + responsePropName + '"]', options);
|
|
} else if (responseBody) {
|
|
for (const key of Object.keys(responseBody))
|
|
if (instance[key] === undefined && !handledPropertyNames.includes(key) && !isSpecialXmlProperty(key, options))
|
|
instance[key] = responseBody[key];
|
|
}
|
|
return instance;
|
|
};
|
|
var deserializeDictionaryType = function(serializer, mapper, responseBody, objectName, options) {
|
|
const value = mapper.type.value;
|
|
if (!value || typeof value !== "object")
|
|
throw new Error(`"value" metadata for a Dictionary must be defined in the ` + `mapper and it must of type "object" in ${objectName}`);
|
|
if (responseBody) {
|
|
const tempDictionary = {};
|
|
for (const key of Object.keys(responseBody))
|
|
tempDictionary[key] = serializer.deserialize(value, responseBody[key], objectName, options);
|
|
return tempDictionary;
|
|
}
|
|
return responseBody;
|
|
};
|
|
var deserializeSequenceType = function(serializer, mapper, responseBody, objectName, options) {
|
|
const element = mapper.type.element;
|
|
if (!element || typeof element !== "object")
|
|
throw new Error(`element" metadata for an Array must be defined in the ` + `mapper and it must of type "object" in ${objectName}`);
|
|
if (responseBody) {
|
|
if (!Array.isArray(responseBody))
|
|
responseBody = [responseBody];
|
|
const tempArray = [];
|
|
for (let i = 0;i < responseBody.length; i++)
|
|
tempArray[i] = serializer.deserialize(element, responseBody[i], `${objectName}[${i}]`, options);
|
|
return tempArray;
|
|
}
|
|
return responseBody;
|
|
};
|
|
var getPolymorphicMapper = function(serializer, mapper, object, polymorphicPropertyName) {
|
|
const polymorphicDiscriminator = getPolymorphicDiscriminatorRecursively(serializer, mapper);
|
|
if (polymorphicDiscriminator) {
|
|
const discriminatorName = polymorphicDiscriminator[polymorphicPropertyName];
|
|
if (discriminatorName != null) {
|
|
const discriminatorValue = object[discriminatorName];
|
|
if (discriminatorValue != null) {
|
|
const typeName = mapper.type.uberParent || mapper.type.className;
|
|
const indexDiscriminator = discriminatorValue === typeName ? discriminatorValue : typeName + "." + discriminatorValue;
|
|
const polymorphicMapper = serializer.modelMappers.discriminators[indexDiscriminator];
|
|
if (polymorphicMapper)
|
|
mapper = polymorphicMapper;
|
|
}
|
|
}
|
|
}
|
|
return mapper;
|
|
};
|
|
var getPolymorphicDiscriminatorRecursively = function(serializer, mapper) {
|
|
return mapper.type.polymorphicDiscriminator || getPolymorphicDiscriminatorSafely(serializer, mapper.type.uberParent) || getPolymorphicDiscriminatorSafely(serializer, mapper.type.className);
|
|
};
|
|
var getPolymorphicDiscriminatorSafely = function(serializer, typeName) {
|
|
return typeName && serializer.modelMappers[typeName] && serializer.modelMappers[typeName].type.polymorphicDiscriminator;
|
|
};
|
|
var serializeObject = function(toSerialize) {
|
|
const castToSerialize = toSerialize;
|
|
if (toSerialize == undefined)
|
|
return;
|
|
if (toSerialize instanceof Uint8Array) {
|
|
toSerialize = encodeByteArray(toSerialize);
|
|
return toSerialize;
|
|
} else if (toSerialize instanceof Date)
|
|
return toSerialize.toISOString();
|
|
else if (Array.isArray(toSerialize)) {
|
|
const array = [];
|
|
for (let i = 0;i < toSerialize.length; i++)
|
|
array.push(serializeObject(toSerialize[i]));
|
|
return array;
|
|
} else if (typeof toSerialize === "object") {
|
|
const dictionary = {};
|
|
for (const property in toSerialize)
|
|
dictionary[property] = serializeObject(castToSerialize[property]);
|
|
return dictionary;
|
|
}
|
|
return toSerialize;
|
|
};
|
|
var strEnum = function(o) {
|
|
const result = {};
|
|
for (const key of o)
|
|
result[key] = key;
|
|
return result;
|
|
};
|
|
var isWebResourceLike = function(object) {
|
|
if (object && typeof object === "object") {
|
|
const castObject = object;
|
|
if (typeof castObject.url === "string" && typeof castObject.method === "string" && typeof castObject.headers === "object" && isHttpHeadersLike(castObject.headers) && typeof castObject.validateRequestProperties === "function" && typeof castObject.prepare === "function" && typeof castObject.clone === "function")
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
var isAlphaNumericCharacter = function(character) {
|
|
const characterCode = character.charCodeAt(0);
|
|
return 48 <= characterCode && characterCode <= 57 || 65 <= characterCode && characterCode <= 90 || 97 <= characterCode && characterCode <= 122;
|
|
};
|
|
var readRemaining = function(tokenizer) {
|
|
let result = "";
|
|
if (tokenizer._currentIndex < tokenizer._textLength) {
|
|
result = tokenizer._text.substring(tokenizer._currentIndex);
|
|
tokenizer._currentIndex = tokenizer._textLength;
|
|
}
|
|
return result;
|
|
};
|
|
var hasCurrentCharacter = function(tokenizer) {
|
|
return tokenizer._currentIndex < tokenizer._textLength;
|
|
};
|
|
var getCurrentCharacter = function(tokenizer) {
|
|
return tokenizer._text[tokenizer._currentIndex];
|
|
};
|
|
var nextCharacter = function(tokenizer, step) {
|
|
if (hasCurrentCharacter(tokenizer)) {
|
|
if (!step)
|
|
step = 1;
|
|
tokenizer._currentIndex += step;
|
|
}
|
|
};
|
|
var peekCharacters = function(tokenizer, charactersToPeek) {
|
|
let endIndex = tokenizer._currentIndex + charactersToPeek;
|
|
if (tokenizer._textLength < endIndex)
|
|
endIndex = tokenizer._textLength;
|
|
return tokenizer._text.substring(tokenizer._currentIndex, endIndex);
|
|
};
|
|
var readWhile = function(tokenizer, condition) {
|
|
let result = "";
|
|
while (hasCurrentCharacter(tokenizer)) {
|
|
const currentCharacter = getCurrentCharacter(tokenizer);
|
|
if (!condition(currentCharacter))
|
|
break;
|
|
else {
|
|
result += currentCharacter;
|
|
nextCharacter(tokenizer);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
var readWhileLetterOrDigit = function(tokenizer) {
|
|
return readWhile(tokenizer, (character) => isAlphaNumericCharacter(character));
|
|
};
|
|
var readUntilCharacter = function(tokenizer, ...terminatingCharacters) {
|
|
return readWhile(tokenizer, (character) => terminatingCharacters.indexOf(character) === -1);
|
|
};
|
|
var nextScheme = function(tokenizer) {
|
|
const scheme = readWhileLetterOrDigit(tokenizer);
|
|
tokenizer._currentToken = URLToken.scheme(scheme);
|
|
if (!hasCurrentCharacter(tokenizer))
|
|
tokenizer._currentState = "DONE";
|
|
else
|
|
tokenizer._currentState = "HOST";
|
|
};
|
|
var nextSchemeOrHost = function(tokenizer) {
|
|
const schemeOrHost = readUntilCharacter(tokenizer, ":", "/", "?");
|
|
if (!hasCurrentCharacter(tokenizer)) {
|
|
tokenizer._currentToken = URLToken.host(schemeOrHost);
|
|
tokenizer._currentState = "DONE";
|
|
} else if (getCurrentCharacter(tokenizer) === ":")
|
|
if (peekCharacters(tokenizer, 3) === "://") {
|
|
tokenizer._currentToken = URLToken.scheme(schemeOrHost);
|
|
tokenizer._currentState = "HOST";
|
|
} else {
|
|
tokenizer._currentToken = URLToken.host(schemeOrHost);
|
|
tokenizer._currentState = "PORT";
|
|
}
|
|
else {
|
|
tokenizer._currentToken = URLToken.host(schemeOrHost);
|
|
if (getCurrentCharacter(tokenizer) === "/")
|
|
tokenizer._currentState = "PATH";
|
|
else
|
|
tokenizer._currentState = "QUERY";
|
|
}
|
|
};
|
|
var nextHost = function(tokenizer) {
|
|
if (peekCharacters(tokenizer, 3) === "://")
|
|
nextCharacter(tokenizer, 3);
|
|
const host = readUntilCharacter(tokenizer, ":", "/", "?");
|
|
tokenizer._currentToken = URLToken.host(host);
|
|
if (!hasCurrentCharacter(tokenizer))
|
|
tokenizer._currentState = "DONE";
|
|
else if (getCurrentCharacter(tokenizer) === ":")
|
|
tokenizer._currentState = "PORT";
|
|
else if (getCurrentCharacter(tokenizer) === "/")
|
|
tokenizer._currentState = "PATH";
|
|
else
|
|
tokenizer._currentState = "QUERY";
|
|
};
|
|
var nextPort = function(tokenizer) {
|
|
if (getCurrentCharacter(tokenizer) === ":")
|
|
nextCharacter(tokenizer);
|
|
const port = readUntilCharacter(tokenizer, "/", "?");
|
|
tokenizer._currentToken = URLToken.port(port);
|
|
if (!hasCurrentCharacter(tokenizer))
|
|
tokenizer._currentState = "DONE";
|
|
else if (getCurrentCharacter(tokenizer) === "/")
|
|
tokenizer._currentState = "PATH";
|
|
else
|
|
tokenizer._currentState = "QUERY";
|
|
};
|
|
var nextPath = function(tokenizer) {
|
|
const path = readUntilCharacter(tokenizer, "?");
|
|
tokenizer._currentToken = URLToken.path(path);
|
|
if (!hasCurrentCharacter(tokenizer))
|
|
tokenizer._currentState = "DONE";
|
|
else
|
|
tokenizer._currentState = "QUERY";
|
|
};
|
|
var nextQuery = function(tokenizer) {
|
|
if (getCurrentCharacter(tokenizer) === "?")
|
|
nextCharacter(tokenizer);
|
|
const query = readRemaining(tokenizer);
|
|
tokenizer._currentToken = URLToken.query(query);
|
|
tokenizer._currentState = "DONE";
|
|
};
|
|
var createProxyAgent = function(requestUrl, proxySettings, headers) {
|
|
const host = URLBuilder.parse(proxySettings.host).getHost();
|
|
if (!host)
|
|
throw new Error("Expecting a non-empty host in proxy settings.");
|
|
if (!isValidPort(proxySettings.port))
|
|
throw new Error("Expecting a valid port number in the range of [0, 65535] in proxy settings.");
|
|
const tunnelOptions = {
|
|
proxy: {
|
|
host,
|
|
port: proxySettings.port,
|
|
headers: headers && headers.rawHeaders() || {}
|
|
}
|
|
};
|
|
if (proxySettings.username && proxySettings.password)
|
|
tunnelOptions.proxy.proxyAuth = `${proxySettings.username}:${proxySettings.password}`;
|
|
else if (proxySettings.username)
|
|
tunnelOptions.proxy.proxyAuth = `${proxySettings.username}`;
|
|
const isRequestHttps = isUrlHttps(requestUrl);
|
|
const isProxyHttps = isUrlHttps(proxySettings.host);
|
|
const proxyAgent = {
|
|
isHttps: isRequestHttps,
|
|
agent: createTunnel(isRequestHttps, isProxyHttps, tunnelOptions)
|
|
};
|
|
return proxyAgent;
|
|
};
|
|
var isUrlHttps = function(url) {
|
|
const urlScheme = URLBuilder.parse(url).getScheme() || "";
|
|
return urlScheme.toLowerCase() === "https";
|
|
};
|
|
var createTunnel = function(isRequestHttps, isProxyHttps, tunnelOptions) {
|
|
if (isRequestHttps && isProxyHttps)
|
|
return tunnel__namespace.httpsOverHttps(tunnelOptions);
|
|
else if (isRequestHttps && !isProxyHttps)
|
|
return tunnel__namespace.httpsOverHttp(tunnelOptions);
|
|
else if (!isRequestHttps && isProxyHttps)
|
|
return tunnel__namespace.httpOverHttps(tunnelOptions);
|
|
else
|
|
return tunnel__namespace.httpOverHttp(tunnelOptions);
|
|
};
|
|
var isValidPort = function(port) {
|
|
return 0 <= port && port <= 65535;
|
|
};
|
|
var getCachedAgent = function(isHttps, agentCache) {
|
|
return isHttps ? agentCache.httpsAgent : agentCache.httpAgent;
|
|
};
|
|
var isReadableStream = function(body) {
|
|
return body && typeof body.pipe === "function";
|
|
};
|
|
var isStreamComplete = function(stream2, aborter) {
|
|
return new Promise((resolve) => {
|
|
stream2.once("close", () => {
|
|
aborter === null || aborter === undefined || aborter.abort();
|
|
resolve();
|
|
});
|
|
stream2.once("end", resolve);
|
|
stream2.once("error", resolve);
|
|
});
|
|
};
|
|
var parseHeaders = function(headers) {
|
|
const httpHeaders = new HttpHeaders;
|
|
headers.forEach((value, key) => {
|
|
httpHeaders.set(key, value);
|
|
});
|
|
return httpHeaders;
|
|
};
|
|
var operationOptionsToRequestOptionsBase = function(opts) {
|
|
const { requestOptions, tracingOptions } = opts, additionalOptions = tslib.__rest(opts, ["requestOptions", "tracingOptions"]);
|
|
let result = additionalOptions;
|
|
if (requestOptions)
|
|
result = Object.assign(Object.assign({}, result), requestOptions);
|
|
if (tracingOptions) {
|
|
result.tracingContext = tracingOptions.tracingContext;
|
|
result.spanOptions = tracingOptions === null || tracingOptions === undefined ? undefined : tracingOptions.spanOptions;
|
|
}
|
|
return result;
|
|
};
|
|
var stringifyXML = function(obj, opts = {}) {
|
|
var _a;
|
|
xml2jsBuilderSettings.rootName = opts.rootName;
|
|
xml2jsBuilderSettings.charkey = (_a = opts.xmlCharKey) !== null && _a !== undefined ? _a : XML_CHARKEY;
|
|
const builder = new xml2js__namespace.Builder(xml2jsBuilderSettings);
|
|
return builder.buildObject(obj);
|
|
};
|
|
var parseXML = function(str, opts = {}) {
|
|
var _a;
|
|
xml2jsParserSettings.explicitRoot = !!opts.includeRoot;
|
|
xml2jsParserSettings.charkey = (_a = opts.xmlCharKey) !== null && _a !== undefined ? _a : XML_CHARKEY;
|
|
const xmlParser = new xml2js__namespace.Parser(xml2jsParserSettings);
|
|
return new Promise((resolve, reject) => {
|
|
if (!str)
|
|
reject(new Error("Document is empty"));
|
|
else
|
|
xmlParser.parseString(str, (err, res) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(res);
|
|
});
|
|
});
|
|
};
|
|
var deserializationPolicy = function(deserializationContentTypes, parsingOptions) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new DeserializationPolicy(nextPolicy, options, deserializationContentTypes, parsingOptions);
|
|
}
|
|
};
|
|
};
|
|
var getOperationResponse = function(parsedResponse) {
|
|
let result;
|
|
const request = parsedResponse.request;
|
|
const operationSpec = request.operationSpec;
|
|
if (operationSpec) {
|
|
const operationResponseGetter = request.operationResponseGetter;
|
|
if (!operationResponseGetter)
|
|
result = operationSpec.responses[parsedResponse.status];
|
|
else
|
|
result = operationResponseGetter(operationSpec, parsedResponse);
|
|
}
|
|
return result;
|
|
};
|
|
var shouldDeserializeResponse = function(parsedResponse) {
|
|
const shouldDeserialize = parsedResponse.request.shouldDeserialize;
|
|
let result;
|
|
if (shouldDeserialize === undefined)
|
|
result = true;
|
|
else if (typeof shouldDeserialize === "boolean")
|
|
result = shouldDeserialize;
|
|
else
|
|
result = shouldDeserialize(parsedResponse);
|
|
return result;
|
|
};
|
|
var deserializeResponseBody = function(jsonContentTypes, xmlContentTypes, response, options = {}) {
|
|
var _a, _b, _c;
|
|
const updatedOptions = {
|
|
rootName: (_a = options.rootName) !== null && _a !== undefined ? _a : "",
|
|
includeRoot: (_b = options.includeRoot) !== null && _b !== undefined ? _b : false,
|
|
xmlCharKey: (_c = options.xmlCharKey) !== null && _c !== undefined ? _c : XML_CHARKEY
|
|
};
|
|
return parse5(jsonContentTypes, xmlContentTypes, response, updatedOptions).then((parsedResponse) => {
|
|
if (!shouldDeserializeResponse(parsedResponse))
|
|
return parsedResponse;
|
|
const operationSpec = parsedResponse.request.operationSpec;
|
|
if (!operationSpec || !operationSpec.responses)
|
|
return parsedResponse;
|
|
const responseSpec = getOperationResponse(parsedResponse);
|
|
const { error, shouldReturnResponse } = handleErrorResponse(parsedResponse, operationSpec, responseSpec);
|
|
if (error)
|
|
throw error;
|
|
else if (shouldReturnResponse)
|
|
return parsedResponse;
|
|
if (responseSpec) {
|
|
if (responseSpec.bodyMapper) {
|
|
let valueToDeserialize = parsedResponse.parsedBody;
|
|
if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperType.Sequence)
|
|
valueToDeserialize = typeof valueToDeserialize === "object" ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName] : [];
|
|
try {
|
|
parsedResponse.parsedBody = operationSpec.serializer.deserialize(responseSpec.bodyMapper, valueToDeserialize, "operationRes.parsedBody", options);
|
|
} catch (innerError) {
|
|
const restError = new RestError(`Error ${innerError} occurred in deserializing the responseBody - ${parsedResponse.bodyAsText}`, undefined, parsedResponse.status, parsedResponse.request, parsedResponse);
|
|
throw restError;
|
|
}
|
|
} else if (operationSpec.httpMethod === "HEAD")
|
|
parsedResponse.parsedBody = response.status >= 200 && response.status < 300;
|
|
if (responseSpec.headersMapper)
|
|
parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(responseSpec.headersMapper, parsedResponse.headers.toJson(), "operationRes.parsedHeaders", options);
|
|
}
|
|
return parsedResponse;
|
|
});
|
|
};
|
|
var isOperationSpecEmpty = function(operationSpec) {
|
|
const expectedStatusCodes = Object.keys(operationSpec.responses);
|
|
return expectedStatusCodes.length === 0 || expectedStatusCodes.length === 1 && expectedStatusCodes[0] === "default";
|
|
};
|
|
var handleErrorResponse = function(parsedResponse, operationSpec, responseSpec) {
|
|
var _a;
|
|
const isSuccessByStatus = 200 <= parsedResponse.status && parsedResponse.status < 300;
|
|
const isExpectedStatusCode = isOperationSpecEmpty(operationSpec) ? isSuccessByStatus : !!responseSpec;
|
|
if (isExpectedStatusCode)
|
|
if (responseSpec) {
|
|
if (!responseSpec.isError)
|
|
return { error: null, shouldReturnResponse: false };
|
|
} else
|
|
return { error: null, shouldReturnResponse: false };
|
|
const errorResponseSpec = responseSpec !== null && responseSpec !== undefined ? responseSpec : operationSpec.responses.default;
|
|
const streaming = ((_a = parsedResponse.request.streamResponseStatusCodes) === null || _a === undefined ? undefined : _a.has(parsedResponse.status)) || parsedResponse.request.streamResponseBody;
|
|
const initialErrorMessage = streaming ? `Unexpected status code: ${parsedResponse.status}` : parsedResponse.bodyAsText;
|
|
const error = new RestError(initialErrorMessage, undefined, parsedResponse.status, parsedResponse.request, parsedResponse);
|
|
if (!errorResponseSpec)
|
|
throw error;
|
|
const defaultBodyMapper = errorResponseSpec.bodyMapper;
|
|
const defaultHeadersMapper = errorResponseSpec.headersMapper;
|
|
try {
|
|
if (parsedResponse.parsedBody) {
|
|
const parsedBody = parsedResponse.parsedBody;
|
|
let parsedError;
|
|
if (defaultBodyMapper) {
|
|
let valueToDeserialize = parsedBody;
|
|
if (operationSpec.isXML && defaultBodyMapper.type.name === MapperType.Sequence)
|
|
valueToDeserialize = typeof parsedBody === "object" ? parsedBody[defaultBodyMapper.xmlElementName] : [];
|
|
parsedError = operationSpec.serializer.deserialize(defaultBodyMapper, valueToDeserialize, "error.response.parsedBody");
|
|
}
|
|
const internalError = parsedBody.error || parsedError || parsedBody;
|
|
error.code = internalError.code;
|
|
if (internalError.message)
|
|
error.message = internalError.message;
|
|
if (defaultBodyMapper)
|
|
error.response.parsedBody = parsedError;
|
|
}
|
|
if (parsedResponse.headers && defaultHeadersMapper)
|
|
error.response.parsedHeaders = operationSpec.serializer.deserialize(defaultHeadersMapper, parsedResponse.headers.toJson(), "operationRes.parsedHeaders");
|
|
} catch (defaultError) {
|
|
error.message = `Error "${defaultError.message}" occurred in deserializing the responseBody - "${parsedResponse.bodyAsText}" for the default response.`;
|
|
}
|
|
return { error, shouldReturnResponse: false };
|
|
};
|
|
var parse5 = function(jsonContentTypes, xmlContentTypes, operationResponse, opts) {
|
|
var _a;
|
|
const errorHandler = (err) => {
|
|
const msg = `Error "${err}" occurred while parsing the response body - ${operationResponse.bodyAsText}.`;
|
|
const errCode = err.code || RestError.PARSE_ERROR;
|
|
const e = new RestError(msg, errCode, operationResponse.status, operationResponse.request, operationResponse);
|
|
return Promise.reject(e);
|
|
};
|
|
const streaming = ((_a = operationResponse.request.streamResponseStatusCodes) === null || _a === undefined ? undefined : _a.has(operationResponse.status)) || operationResponse.request.streamResponseBody;
|
|
if (!streaming && operationResponse.bodyAsText) {
|
|
const text = operationResponse.bodyAsText;
|
|
const contentType = operationResponse.headers.get("Content-Type") || "";
|
|
const contentComponents = !contentType ? [] : contentType.split(";").map((component) => component.toLowerCase());
|
|
if (contentComponents.length === 0 || contentComponents.some((component) => jsonContentTypes.indexOf(component) !== -1))
|
|
return new Promise((resolve) => {
|
|
operationResponse.parsedBody = JSON.parse(text);
|
|
resolve(operationResponse);
|
|
}).catch(errorHandler);
|
|
else if (contentComponents.some((component) => xmlContentTypes.indexOf(component) !== -1))
|
|
return parseXML(text, opts).then((body) => {
|
|
operationResponse.parsedBody = body;
|
|
return operationResponse;
|
|
}).catch(errorHandler);
|
|
}
|
|
return Promise.resolve(operationResponse);
|
|
};
|
|
var keepAlivePolicy = function(keepAliveOptions) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new KeepAlivePolicy(nextPolicy, options, keepAliveOptions || DefaultKeepAliveOptions);
|
|
}
|
|
};
|
|
};
|
|
var redirectPolicy = function(maximumRetries = 20) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new RedirectPolicy(nextPolicy, options, maximumRetries);
|
|
}
|
|
};
|
|
};
|
|
var handleRedirect = function(policy, response, currentRetries) {
|
|
const { request, status } = response;
|
|
const locationHeader = response.headers.get("location");
|
|
if (locationHeader && (status === 300 || status === 301 && allowedRedirect.includes(request.method) || status === 302 && allowedRedirect.includes(request.method) || status === 303 && request.method === "POST" || status === 307) && (!policy.maxRetries || currentRetries < policy.maxRetries)) {
|
|
const builder = URLBuilder.parse(request.url);
|
|
builder.setPath(locationHeader);
|
|
request.url = builder.toString();
|
|
if (status === 303) {
|
|
request.method = "GET";
|
|
delete request.body;
|
|
}
|
|
return policy._nextPolicy.sendRequest(request).then((res) => handleRedirect(policy, res, currentRetries + 1));
|
|
}
|
|
return Promise.resolve(response);
|
|
};
|
|
var isNumber = function(n) {
|
|
return typeof n === "number";
|
|
};
|
|
var shouldRetry = function(retryLimit, predicate, retryData, response, error) {
|
|
if (!predicate(response, error))
|
|
return false;
|
|
return retryData.retryCount < retryLimit;
|
|
};
|
|
var updateRetryData = function(retryOptions, retryData = { retryCount: 0, retryInterval: 0 }, err) {
|
|
if (err) {
|
|
if (retryData.error)
|
|
err.innerError = retryData.error;
|
|
retryData.error = err;
|
|
}
|
|
retryData.retryCount++;
|
|
let incrementDelta = Math.pow(2, retryData.retryCount - 1) - 1;
|
|
const boundedRandDelta = retryOptions.retryInterval * 0.8 + Math.floor(Math.random() * (retryOptions.retryInterval * 0.4));
|
|
incrementDelta *= boundedRandDelta;
|
|
retryData.retryInterval = Math.min(retryOptions.minRetryInterval + incrementDelta, retryOptions.maxRetryInterval);
|
|
return retryData;
|
|
};
|
|
var exponentialRetryPolicy = function(retryCount, retryInterval, maxRetryInterval) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new ExponentialRetryPolicy(nextPolicy, options, retryCount, retryInterval, maxRetryInterval);
|
|
}
|
|
};
|
|
};
|
|
async function retry$1(policy, request, response, retryData, requestError) {
|
|
function shouldPolicyRetry(responseParam) {
|
|
const statusCode = responseParam === null || responseParam === undefined ? undefined : responseParam.status;
|
|
if (statusCode === 503 && (response === null || response === undefined ? undefined : response.headers.get(Constants.HeaderConstants.RETRY_AFTER)))
|
|
return false;
|
|
if (statusCode === undefined || statusCode < 500 && statusCode !== 408 || statusCode === 501 || statusCode === 505)
|
|
return false;
|
|
return true;
|
|
}
|
|
retryData = updateRetryData({
|
|
retryInterval: policy.retryInterval,
|
|
minRetryInterval: 0,
|
|
maxRetryInterval: policy.maxRetryInterval
|
|
}, retryData, requestError);
|
|
const isAborted = request.abortSignal && request.abortSignal.aborted;
|
|
if (!isAborted && shouldRetry(policy.retryCount, shouldPolicyRetry, retryData, response)) {
|
|
logger.info(`Retrying request in ${retryData.retryInterval}`);
|
|
try {
|
|
await coreUtil.delay(retryData.retryInterval);
|
|
const res = await policy._nextPolicy.sendRequest(request.clone());
|
|
return retry$1(policy, request, res, retryData);
|
|
} catch (err) {
|
|
return retry$1(policy, request, response, retryData, err);
|
|
}
|
|
} else if (isAborted || requestError || !response) {
|
|
const err = retryData.error || new RestError("Failed to send the request.", RestError.REQUEST_SEND_ERROR, response && response.status, response && response.request, response);
|
|
throw err;
|
|
} else
|
|
return response;
|
|
}
|
|
var logPolicy = function(loggingOptions = {}) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new LogPolicy(nextPolicy, options, loggingOptions);
|
|
}
|
|
};
|
|
};
|
|
var getPathStringFromParameter = function(parameter) {
|
|
return getPathStringFromParameterPath(parameter.parameterPath, parameter.mapper);
|
|
};
|
|
var getPathStringFromParameterPath = function(parameterPath, mapper) {
|
|
let result;
|
|
if (typeof parameterPath === "string")
|
|
result = parameterPath;
|
|
else if (Array.isArray(parameterPath))
|
|
result = parameterPath.join(".");
|
|
else
|
|
result = mapper.serializedName;
|
|
return result;
|
|
};
|
|
var getStreamResponseStatusCodes = function(operationSpec) {
|
|
const result = new Set;
|
|
for (const statusCode in operationSpec.responses) {
|
|
const operationResponse = operationSpec.responses[statusCode];
|
|
if (operationResponse.bodyMapper && operationResponse.bodyMapper.type.name === MapperType.Stream)
|
|
result.add(Number(statusCode));
|
|
}
|
|
return result;
|
|
};
|
|
var getDefaultUserAgentKey = function() {
|
|
return Constants.HeaderConstants.USER_AGENT;
|
|
};
|
|
var getPlatformSpecificData = function() {
|
|
const runtimeInfo = {
|
|
key: "Node",
|
|
value: process.version
|
|
};
|
|
const osInfo = {
|
|
key: "OS",
|
|
value: `(${os__namespace.arch()}-${os__namespace.type()}-${os__namespace.release()})`
|
|
};
|
|
return [runtimeInfo, osInfo];
|
|
};
|
|
var getRuntimeInfo = function() {
|
|
const msRestRuntime = {
|
|
key: "core-http",
|
|
value: Constants.coreHttpVersion
|
|
};
|
|
return [msRestRuntime];
|
|
};
|
|
var getUserAgentString = function(telemetryInfo, keySeparator = " ", valueSeparator = "/") {
|
|
return telemetryInfo.map((info) => {
|
|
const value = info.value ? `${valueSeparator}${info.value}` : "";
|
|
return `${info.key}${value}`;
|
|
}).join(keySeparator);
|
|
};
|
|
var getDefaultUserAgentValue = function() {
|
|
const runtimeInfo = getRuntimeInfo();
|
|
const platformSpecificData = getPlatformSpecificData();
|
|
const userAgent = getUserAgentString(runtimeInfo.concat(platformSpecificData));
|
|
return userAgent;
|
|
};
|
|
var userAgentPolicy = function(userAgentData) {
|
|
const key = !userAgentData || userAgentData.key === undefined || userAgentData.key === null ? getDefaultUserAgentKey() : userAgentData.key;
|
|
const value = !userAgentData || userAgentData.value === undefined || userAgentData.value === null ? getDefaultUserAgentValue() : userAgentData.value;
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new UserAgentPolicy(nextPolicy, options, key, value);
|
|
}
|
|
};
|
|
};
|
|
async function beginRefresh(getAccessToken, retryIntervalInMs, timeoutInMs) {
|
|
async function tryGetAccessToken() {
|
|
if (Date.now() < timeoutInMs)
|
|
try {
|
|
return await getAccessToken();
|
|
} catch (_a) {
|
|
return null;
|
|
}
|
|
else {
|
|
const finalToken = await getAccessToken();
|
|
if (finalToken === null)
|
|
throw new Error("Failed to refresh access token.");
|
|
return finalToken;
|
|
}
|
|
}
|
|
let token = await tryGetAccessToken();
|
|
while (token === null) {
|
|
await coreUtil.delay(retryIntervalInMs);
|
|
token = await tryGetAccessToken();
|
|
}
|
|
return token;
|
|
}
|
|
var createTokenCycler = function(credential, scopes, tokenCyclerOptions) {
|
|
let refreshWorker = null;
|
|
let token = null;
|
|
const options = Object.assign(Object.assign({}, DEFAULT_CYCLER_OPTIONS), tokenCyclerOptions);
|
|
const cycler = {
|
|
get isRefreshing() {
|
|
return refreshWorker !== null;
|
|
},
|
|
get shouldRefresh() {
|
|
var _a;
|
|
return !cycler.isRefreshing && ((_a = token === null || token === undefined ? undefined : token.expiresOnTimestamp) !== null && _a !== undefined ? _a : 0) - options.refreshWindowInMs < Date.now();
|
|
},
|
|
get mustRefresh() {
|
|
return token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now();
|
|
}
|
|
};
|
|
function refresh(getTokenOptions) {
|
|
var _a;
|
|
if (!cycler.isRefreshing) {
|
|
const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
|
|
refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, (_a = token === null || token === undefined ? undefined : token.expiresOnTimestamp) !== null && _a !== undefined ? _a : Date.now()).then((_token) => {
|
|
refreshWorker = null;
|
|
token = _token;
|
|
return token;
|
|
}).catch((reason) => {
|
|
refreshWorker = null;
|
|
token = null;
|
|
throw reason;
|
|
});
|
|
}
|
|
return refreshWorker;
|
|
}
|
|
return async (tokenOptions) => {
|
|
if (cycler.mustRefresh)
|
|
return refresh(tokenOptions);
|
|
if (cycler.shouldRefresh)
|
|
refresh(tokenOptions);
|
|
return token;
|
|
};
|
|
};
|
|
var bearerTokenAuthenticationPolicy = function(credential, scopes) {
|
|
const getToken = createTokenCycler(credential, scopes);
|
|
|
|
class BearerTokenAuthenticationPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(webResource) {
|
|
if (!webResource.url.toLowerCase().startsWith("https://"))
|
|
throw new Error("Bearer token authentication is not permitted for non-TLS protected (non-https) URLs.");
|
|
const { token } = await getToken({
|
|
abortSignal: webResource.abortSignal,
|
|
tracingOptions: {
|
|
tracingContext: webResource.tracingContext
|
|
}
|
|
});
|
|
webResource.headers.set(Constants.HeaderConstants.AUTHORIZATION, `Bearer ${token}`);
|
|
return this._nextPolicy.sendRequest(webResource);
|
|
}
|
|
}
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new BearerTokenAuthenticationPolicy(nextPolicy, options);
|
|
}
|
|
};
|
|
};
|
|
var disableResponseDecompressionPolicy = function() {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new DisableResponseDecompressionPolicy(nextPolicy, options);
|
|
}
|
|
};
|
|
};
|
|
var generateClientRequestIdPolicy = function(requestIdHeaderName = "x-ms-client-request-id") {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new GenerateClientRequestIdPolicy(nextPolicy, options, requestIdHeaderName);
|
|
}
|
|
};
|
|
};
|
|
var getCachedDefaultHttpClient = function() {
|
|
if (!cachedHttpClient)
|
|
cachedHttpClient = new NodeFetchHttpClient;
|
|
return cachedHttpClient;
|
|
};
|
|
var ndJsonPolicy = function() {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new NdJsonPolicy(nextPolicy, options);
|
|
}
|
|
};
|
|
};
|
|
var loadEnvironmentProxyValue = function() {
|
|
if (!process)
|
|
return;
|
|
const httpsProxy = getEnvironmentValue(Constants.HTTPS_PROXY);
|
|
const allProxy = getEnvironmentValue(Constants.ALL_PROXY);
|
|
const httpProxy = getEnvironmentValue(Constants.HTTP_PROXY);
|
|
return httpsProxy || allProxy || httpProxy;
|
|
};
|
|
var isBypassed = function(uri, noProxyList, bypassedMap) {
|
|
if (noProxyList.length === 0)
|
|
return false;
|
|
const host = URLBuilder.parse(uri).getHost();
|
|
if (bypassedMap === null || bypassedMap === undefined ? undefined : bypassedMap.has(host))
|
|
return bypassedMap.get(host);
|
|
let isBypassedFlag = false;
|
|
for (const pattern of noProxyList)
|
|
if (pattern[0] === ".") {
|
|
if (host.endsWith(pattern))
|
|
isBypassedFlag = true;
|
|
else if (host.length === pattern.length - 1 && host === pattern.slice(1))
|
|
isBypassedFlag = true;
|
|
} else if (host === pattern)
|
|
isBypassedFlag = true;
|
|
bypassedMap === null || bypassedMap === undefined || bypassedMap.set(host, isBypassedFlag);
|
|
return isBypassedFlag;
|
|
};
|
|
var loadNoProxy = function() {
|
|
const noProxy = getEnvironmentValue(Constants.NO_PROXY);
|
|
noProxyListLoaded = true;
|
|
if (noProxy)
|
|
return noProxy.split(",").map((item) => item.trim()).filter((item) => item.length);
|
|
return [];
|
|
};
|
|
var getDefaultProxySettings = function(proxyUrl) {
|
|
if (!proxyUrl) {
|
|
proxyUrl = loadEnvironmentProxyValue();
|
|
if (!proxyUrl)
|
|
return;
|
|
}
|
|
const { username, password, urlWithoutAuth } = extractAuthFromUrl(proxyUrl);
|
|
const parsedUrl = URLBuilder.parse(urlWithoutAuth);
|
|
const schema = parsedUrl.getScheme() ? parsedUrl.getScheme() + "://" : "";
|
|
return {
|
|
host: schema + parsedUrl.getHost(),
|
|
port: Number.parseInt(parsedUrl.getPort() || "80"),
|
|
username,
|
|
password
|
|
};
|
|
};
|
|
var proxyPolicy = function(proxySettings, options) {
|
|
if (!proxySettings)
|
|
proxySettings = getDefaultProxySettings();
|
|
if (!noProxyListLoaded)
|
|
globalNoProxyList.push(...loadNoProxy());
|
|
return {
|
|
create: (nextPolicy, requestPolicyOptions) => {
|
|
return new ProxyPolicy(nextPolicy, requestPolicyOptions, proxySettings, options === null || options === undefined ? undefined : options.customNoProxyList);
|
|
}
|
|
};
|
|
};
|
|
var extractAuthFromUrl = function(url) {
|
|
const atIndex = url.indexOf("@");
|
|
if (atIndex === -1)
|
|
return { urlWithoutAuth: url };
|
|
const schemeIndex = url.indexOf("://");
|
|
const authStart = schemeIndex !== -1 ? schemeIndex + 3 : 0;
|
|
const auth = url.substring(authStart, atIndex);
|
|
const colonIndex = auth.indexOf(":");
|
|
const hasPassword = colonIndex !== -1;
|
|
const username = hasPassword ? auth.substring(0, colonIndex) : auth;
|
|
const password = hasPassword ? auth.substring(colonIndex + 1) : undefined;
|
|
const urlWithoutAuth = url.substring(0, authStart) + url.substring(atIndex + 1);
|
|
return {
|
|
username,
|
|
password,
|
|
urlWithoutAuth
|
|
};
|
|
};
|
|
var rpRegistrationPolicy = function(retryTimeout = 30) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new RPRegistrationPolicy(nextPolicy, options, retryTimeout);
|
|
}
|
|
};
|
|
};
|
|
var registerIfNeeded = function(policy, request, response) {
|
|
if (response.status === 409) {
|
|
const rpName = checkRPNotRegisteredError(response.bodyAsText);
|
|
if (rpName) {
|
|
const urlPrefix = extractSubscriptionUrl(request.url);
|
|
return registerRP(policy, urlPrefix, rpName, request).catch(() => false).then((registrationStatus) => {
|
|
if (registrationStatus) {
|
|
request.headers.set("x-ms-client-request-id", generateUuid());
|
|
return policy._nextPolicy.sendRequest(request.clone());
|
|
}
|
|
return response;
|
|
});
|
|
}
|
|
}
|
|
return Promise.resolve(response);
|
|
};
|
|
var getRequestEssentials = function(originalRequest, reuseUrlToo = false) {
|
|
const reqOptions = originalRequest.clone();
|
|
if (reuseUrlToo)
|
|
reqOptions.url = originalRequest.url;
|
|
reqOptions.headers.set("x-ms-client-request-id", generateUuid());
|
|
reqOptions.headers.set("Content-Type", "application/json; charset=utf-8");
|
|
return reqOptions;
|
|
};
|
|
var checkRPNotRegisteredError = function(body) {
|
|
let result, responseBody;
|
|
if (body) {
|
|
try {
|
|
responseBody = JSON.parse(body);
|
|
} catch (err) {
|
|
}
|
|
if (responseBody && responseBody.error && responseBody.error.message && responseBody.error.code && responseBody.error.code === "MissingSubscriptionRegistration") {
|
|
const matchRes = responseBody.error.message.match(/.*'(.*)'/i);
|
|
if (matchRes)
|
|
result = matchRes.pop();
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
var extractSubscriptionUrl = function(url) {
|
|
let result;
|
|
const matchRes = url.match(/.*\/subscriptions\/[a-f0-9-]+\//gi);
|
|
if (matchRes && matchRes[0])
|
|
result = matchRes[0];
|
|
else
|
|
throw new Error(`Unable to extract subscriptionId from the given url - ${url}.`);
|
|
return result;
|
|
};
|
|
async function registerRP(policy, urlPrefix, provider, originalRequest) {
|
|
const postUrl = `${urlPrefix}providers/${provider}/register?api-version=2016-02-01`;
|
|
const getUrl = `${urlPrefix}providers/${provider}?api-version=2016-02-01`;
|
|
const reqOptions = getRequestEssentials(originalRequest);
|
|
reqOptions.method = "POST";
|
|
reqOptions.url = postUrl;
|
|
const response = await policy._nextPolicy.sendRequest(reqOptions);
|
|
if (response.status !== 200)
|
|
throw new Error(`Autoregistration of ${provider} failed. Please try registering manually.`);
|
|
return getRegistrationStatus(policy, getUrl, originalRequest);
|
|
}
|
|
async function getRegistrationStatus(policy, url, originalRequest) {
|
|
const reqOptions = getRequestEssentials(originalRequest);
|
|
reqOptions.url = url;
|
|
reqOptions.method = "GET";
|
|
const res = await policy._nextPolicy.sendRequest(reqOptions);
|
|
const obj = res.parsedBody;
|
|
if (res.parsedBody && obj.registrationState && obj.registrationState === "Registered")
|
|
return true;
|
|
else {
|
|
await coreUtil.delay(policy._retryTimeout * 1000);
|
|
return getRegistrationStatus(policy, url, originalRequest);
|
|
}
|
|
}
|
|
var signingPolicy = function(authenticationProvider) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new SigningPolicy(nextPolicy, options, authenticationProvider);
|
|
}
|
|
};
|
|
};
|
|
var systemErrorRetryPolicy = function(retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new SystemErrorRetryPolicy(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval);
|
|
}
|
|
};
|
|
};
|
|
async function retry(policy, request, operationResponse, err, retryData) {
|
|
retryData = updateRetryData(policy, retryData, err);
|
|
function shouldPolicyRetry(_response, error) {
|
|
if (error && error.code && (error.code === "ETIMEDOUT" || error.code === "ESOCKETTIMEDOUT" || error.code === "ECONNREFUSED" || error.code === "ECONNRESET" || error.code === "ENOENT"))
|
|
return true;
|
|
return false;
|
|
}
|
|
if (shouldRetry(policy.retryCount, shouldPolicyRetry, retryData, operationResponse, err))
|
|
try {
|
|
await coreUtil.delay(retryData.retryInterval);
|
|
return policy._nextPolicy.sendRequest(request.clone());
|
|
} catch (nestedErr) {
|
|
return retry(policy, request, operationResponse, nestedErr, retryData);
|
|
}
|
|
else {
|
|
if (err)
|
|
return Promise.reject(retryData.error);
|
|
return operationResponse;
|
|
}
|
|
}
|
|
var throttlingRetryPolicy = function() {
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new ThrottlingRetryPolicy(nextPolicy, options);
|
|
}
|
|
};
|
|
};
|
|
var tracingPolicy = function(tracingOptions = {}) {
|
|
return {
|
|
create(nextPolicy, options) {
|
|
return new TracingPolicy(nextPolicy, options, tracingOptions);
|
|
}
|
|
};
|
|
};
|
|
var serializeRequestBody = function(serviceClient, httpRequest, operationArguments, operationSpec) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const serializerOptions = (_b = (_a = operationArguments.options) === null || _a === undefined ? undefined : _a.serializerOptions) !== null && _b !== undefined ? _b : {};
|
|
const updatedOptions = {
|
|
rootName: (_c = serializerOptions.rootName) !== null && _c !== undefined ? _c : "",
|
|
includeRoot: (_d = serializerOptions.includeRoot) !== null && _d !== undefined ? _d : false,
|
|
xmlCharKey: (_e = serializerOptions.xmlCharKey) !== null && _e !== undefined ? _e : XML_CHARKEY
|
|
};
|
|
const xmlCharKey = serializerOptions.xmlCharKey;
|
|
if (operationSpec.requestBody && operationSpec.requestBody.mapper) {
|
|
httpRequest.body = getOperationArgumentValueFromParameter(serviceClient, operationArguments, operationSpec.requestBody, operationSpec.serializer);
|
|
const bodyMapper = operationSpec.requestBody.mapper;
|
|
const { required, xmlName, xmlElementName, serializedName, xmlNamespace, xmlNamespacePrefix } = bodyMapper;
|
|
const typeName = bodyMapper.type.name;
|
|
try {
|
|
if (httpRequest.body !== undefined && httpRequest.body !== null || required) {
|
|
const requestBodyParameterPathString = getPathStringFromParameter(operationSpec.requestBody);
|
|
httpRequest.body = operationSpec.serializer.serialize(bodyMapper, httpRequest.body, requestBodyParameterPathString, updatedOptions);
|
|
const isStream = typeName === MapperType.Stream;
|
|
if (operationSpec.isXML) {
|
|
const xmlnsKey = xmlNamespacePrefix ? `xmlns:${xmlNamespacePrefix}` : "xmlns";
|
|
const value = getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, httpRequest.body, updatedOptions);
|
|
if (typeName === MapperType.Sequence)
|
|
httpRequest.body = stringifyXML(prepareXMLRootList(value, xmlElementName || xmlName || serializedName, xmlnsKey, xmlNamespace), {
|
|
rootName: xmlName || serializedName,
|
|
xmlCharKey
|
|
});
|
|
else if (!isStream)
|
|
httpRequest.body = stringifyXML(value, {
|
|
rootName: xmlName || serializedName,
|
|
xmlCharKey
|
|
});
|
|
} else if (typeName === MapperType.String && (((_f = operationSpec.contentType) === null || _f === undefined ? undefined : _f.match("text/plain")) || operationSpec.mediaType === "text"))
|
|
return;
|
|
else if (!isStream)
|
|
httpRequest.body = JSON.stringify(httpRequest.body);
|
|
}
|
|
} catch (error) {
|
|
throw new Error(`Error "${error.message}" occurred in serializing the payload - ${JSON.stringify(serializedName, undefined, " ")}.`);
|
|
}
|
|
} else if (operationSpec.formDataParameters && operationSpec.formDataParameters.length > 0) {
|
|
httpRequest.formData = {};
|
|
for (const formDataParameter of operationSpec.formDataParameters) {
|
|
const formDataParameterValue = getOperationArgumentValueFromParameter(serviceClient, operationArguments, formDataParameter, operationSpec.serializer);
|
|
if (formDataParameterValue !== undefined && formDataParameterValue !== null) {
|
|
const formDataParameterPropertyName = formDataParameter.mapper.serializedName || getPathStringFromParameter(formDataParameter);
|
|
httpRequest.formData[formDataParameterPropertyName] = operationSpec.serializer.serialize(formDataParameter.mapper, formDataParameterValue, getPathStringFromParameter(formDataParameter), updatedOptions);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var getXmlValueWithNamespace = function(xmlNamespace, xmlnsKey, typeName, serializedValue, options) {
|
|
if (xmlNamespace && !["Composite", "Sequence", "Dictionary"].includes(typeName)) {
|
|
const result = {};
|
|
result[options.xmlCharKey] = serializedValue;
|
|
result[XML_ATTRKEY] = { [xmlnsKey]: xmlNamespace };
|
|
return result;
|
|
}
|
|
return serializedValue;
|
|
};
|
|
var getValueOrFunctionResult = function(value, defaultValueCreator) {
|
|
let result;
|
|
if (typeof value === "string")
|
|
result = value;
|
|
else {
|
|
result = defaultValueCreator();
|
|
if (typeof value === "function")
|
|
result = value(result);
|
|
}
|
|
return result;
|
|
};
|
|
var createDefaultRequestPolicyFactories = function(authPolicyFactory, options) {
|
|
const factories = [];
|
|
if (options.generateClientRequestIdHeader)
|
|
factories.push(generateClientRequestIdPolicy(options.clientRequestIdHeaderName));
|
|
if (authPolicyFactory)
|
|
factories.push(authPolicyFactory);
|
|
const userAgentHeaderName = getValueOrFunctionResult(options.userAgentHeaderName, getDefaultUserAgentHeaderName);
|
|
const userAgentHeaderValue = getValueOrFunctionResult(options.userAgent, getDefaultUserAgentValue);
|
|
if (userAgentHeaderName && userAgentHeaderValue)
|
|
factories.push(userAgentPolicy({ key: userAgentHeaderName, value: userAgentHeaderValue }));
|
|
factories.push(redirectPolicy());
|
|
factories.push(rpRegistrationPolicy(options.rpRegistrationRetryTimeout));
|
|
if (!options.noRetryPolicy) {
|
|
factories.push(exponentialRetryPolicy());
|
|
factories.push(systemErrorRetryPolicy());
|
|
factories.push(throttlingRetryPolicy());
|
|
}
|
|
factories.push(deserializationPolicy(options.deserializationContentTypes));
|
|
if (isNode)
|
|
factories.push(proxyPolicy(options.proxySettings));
|
|
factories.push(logPolicy({ logger: logger.info }));
|
|
return factories;
|
|
};
|
|
var createPipelineFromOptions = function(pipelineOptions, authPolicyFactory) {
|
|
const requestPolicyFactories = [];
|
|
if (pipelineOptions.sendStreamingJson)
|
|
requestPolicyFactories.push(ndJsonPolicy());
|
|
let userAgentValue = undefined;
|
|
if (pipelineOptions.userAgentOptions && pipelineOptions.userAgentOptions.userAgentPrefix) {
|
|
const userAgentInfo = [];
|
|
userAgentInfo.push(pipelineOptions.userAgentOptions.userAgentPrefix);
|
|
const defaultUserAgentInfo = getDefaultUserAgentValue();
|
|
if (userAgentInfo.indexOf(defaultUserAgentInfo) === -1)
|
|
userAgentInfo.push(defaultUserAgentInfo);
|
|
userAgentValue = userAgentInfo.join(" ");
|
|
}
|
|
const keepAliveOptions = Object.assign(Object.assign({}, DefaultKeepAliveOptions), pipelineOptions.keepAliveOptions);
|
|
const retryOptions = Object.assign(Object.assign({}, DefaultRetryOptions), pipelineOptions.retryOptions);
|
|
const redirectOptions = Object.assign(Object.assign({}, DefaultRedirectOptions), pipelineOptions.redirectOptions);
|
|
if (isNode)
|
|
requestPolicyFactories.push(proxyPolicy(pipelineOptions.proxyOptions));
|
|
const deserializationOptions = Object.assign(Object.assign({}, DefaultDeserializationOptions), pipelineOptions.deserializationOptions);
|
|
const loggingOptions = Object.assign({}, pipelineOptions.loggingOptions);
|
|
requestPolicyFactories.push(tracingPolicy({ userAgent: userAgentValue }), keepAlivePolicy(keepAliveOptions), userAgentPolicy({ value: userAgentValue }), generateClientRequestIdPolicy(), deserializationPolicy(deserializationOptions.expectedContentTypes), throttlingRetryPolicy(), systemErrorRetryPolicy(), exponentialRetryPolicy(retryOptions.maxRetries, retryOptions.retryDelayInMs, retryOptions.maxRetryDelayInMs));
|
|
if (redirectOptions.handleRedirects)
|
|
requestPolicyFactories.push(redirectPolicy(redirectOptions.maxRetries));
|
|
if (authPolicyFactory)
|
|
requestPolicyFactories.push(authPolicyFactory);
|
|
requestPolicyFactories.push(logPolicy(loggingOptions));
|
|
if (isNode && pipelineOptions.decompressResponse === false)
|
|
requestPolicyFactories.push(disableResponseDecompressionPolicy());
|
|
return {
|
|
httpClient: pipelineOptions.httpClient,
|
|
requestPolicyFactories
|
|
};
|
|
};
|
|
var getOperationArgumentValueFromParameter = function(serviceClient, operationArguments, parameter, serializer) {
|
|
return getOperationArgumentValueFromParameterPath(serviceClient, operationArguments, parameter.parameterPath, parameter.mapper, serializer);
|
|
};
|
|
var getOperationArgumentValueFromParameterPath = function(serviceClient, operationArguments, parameterPath, parameterMapper, serializer) {
|
|
var _a;
|
|
let value;
|
|
if (typeof parameterPath === "string")
|
|
parameterPath = [parameterPath];
|
|
const serializerOptions = (_a = operationArguments.options) === null || _a === undefined ? undefined : _a.serializerOptions;
|
|
if (Array.isArray(parameterPath)) {
|
|
if (parameterPath.length > 0) {
|
|
if (parameterMapper.isConstant)
|
|
value = parameterMapper.defaultValue;
|
|
else {
|
|
let propertySearchResult = getPropertyFromParameterPath(operationArguments, parameterPath);
|
|
if (!propertySearchResult.propertyFound)
|
|
propertySearchResult = getPropertyFromParameterPath(serviceClient, parameterPath);
|
|
let useDefaultValue = false;
|
|
if (!propertySearchResult.propertyFound)
|
|
useDefaultValue = parameterMapper.required || parameterPath[0] === "options" && parameterPath.length === 2;
|
|
value = useDefaultValue ? parameterMapper.defaultValue : propertySearchResult.propertyValue;
|
|
}
|
|
const parameterPathString = getPathStringFromParameterPath(parameterPath, parameterMapper);
|
|
serializer.serialize(parameterMapper, value, parameterPathString, serializerOptions);
|
|
}
|
|
} else {
|
|
if (parameterMapper.required)
|
|
value = {};
|
|
for (const propertyName in parameterPath) {
|
|
const propertyMapper = parameterMapper.type.modelProperties[propertyName];
|
|
const propertyPath = parameterPath[propertyName];
|
|
const propertyValue = getOperationArgumentValueFromParameterPath(serviceClient, operationArguments, propertyPath, propertyMapper, serializer);
|
|
const propertyPathString = getPathStringFromParameterPath(propertyPath, propertyMapper);
|
|
serializer.serialize(propertyMapper, propertyValue, propertyPathString, serializerOptions);
|
|
if (propertyValue !== undefined && propertyValue !== null) {
|
|
if (!value)
|
|
value = {};
|
|
value[propertyName] = propertyValue;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
var getPropertyFromParameterPath = function(parent, parameterPath) {
|
|
const result = { propertyFound: false };
|
|
let i = 0;
|
|
for (;i < parameterPath.length; ++i) {
|
|
const parameterPathPart = parameterPath[i];
|
|
if (parent !== undefined && parent !== null && (parameterPathPart in parent))
|
|
parent = parent[parameterPathPart];
|
|
else
|
|
break;
|
|
}
|
|
if (i === parameterPath.length) {
|
|
result.propertyValue = parent;
|
|
result.propertyFound = true;
|
|
}
|
|
return result;
|
|
};
|
|
var flattenResponse = function(_response, responseSpec) {
|
|
const parsedHeaders = _response.parsedHeaders;
|
|
const bodyMapper = responseSpec && responseSpec.bodyMapper;
|
|
const addOperationResponse = (obj) => {
|
|
return Object.defineProperty(obj, "_response", {
|
|
value: _response
|
|
});
|
|
};
|
|
if (bodyMapper) {
|
|
const typeName = bodyMapper.type.name;
|
|
if (typeName === "Stream")
|
|
return addOperationResponse(Object.assign(Object.assign({}, parsedHeaders), { blobBody: _response.blobBody, readableStreamBody: _response.readableStreamBody }));
|
|
const modelProperties = typeName === "Composite" && bodyMapper.type.modelProperties || {};
|
|
const isPageableResponse = Object.keys(modelProperties).some((k) => modelProperties[k].serializedName === "");
|
|
if (typeName === "Sequence" || isPageableResponse) {
|
|
const arrayResponse = [..._response.parsedBody || []];
|
|
for (const key of Object.keys(modelProperties))
|
|
if (modelProperties[key].serializedName)
|
|
arrayResponse[key] = _response.parsedBody[key];
|
|
if (parsedHeaders)
|
|
for (const key of Object.keys(parsedHeaders))
|
|
arrayResponse[key] = parsedHeaders[key];
|
|
addOperationResponse(arrayResponse);
|
|
return arrayResponse;
|
|
}
|
|
if (typeName === "Composite" || typeName === "Dictionary")
|
|
return addOperationResponse(Object.assign(Object.assign({}, parsedHeaders), _response.parsedBody));
|
|
}
|
|
if (bodyMapper || _response.request.method === "HEAD" || isPrimitiveType(_response.parsedBody))
|
|
return addOperationResponse(Object.assign(Object.assign({}, parsedHeaders), { body: _response.parsedBody }));
|
|
return addOperationResponse(Object.assign(Object.assign({}, parsedHeaders), _response.parsedBody));
|
|
};
|
|
var getCredentialScopes = function(options, baseUri) {
|
|
if (options === null || options === undefined ? undefined : options.credentialScopes) {
|
|
const scopes = options.credentialScopes;
|
|
return Array.isArray(scopes) ? scopes.map((scope) => new URL(scope).toString()) : new URL(scopes).toString();
|
|
}
|
|
if (baseUri)
|
|
return `${baseUri}/.default`;
|
|
return;
|
|
};
|
|
var createSpanFunction = function(args) {
|
|
return coreTracing.createSpanFunction(args);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var uuid = (init_esm_node2(), __toCommonJS(exports_esm_node2));
|
|
var util = __require("util");
|
|
var tslib = (init_tslib_es6(), __toCommonJS(exports_tslib_es6));
|
|
var xml2js = require_xml2js();
|
|
var coreUtil = require_dist2();
|
|
var logger$1 = require_dist3();
|
|
var coreAuth = require_dist4();
|
|
var os = __require("os");
|
|
var http = __require("http");
|
|
var https = __require("https");
|
|
var abortController = require_dist();
|
|
var tunnel = require_tunnel();
|
|
var stream = __require("stream");
|
|
var FormData = require_form_data();
|
|
var node_fetch = require_lib4();
|
|
var coreTracing = require_dist5();
|
|
var xml2js__namespace = _interopNamespace(xml2js);
|
|
var os__namespace = _interopNamespace(os);
|
|
var http__namespace = _interopNamespace(http);
|
|
var https__namespace = _interopNamespace(https);
|
|
var tunnel__namespace = _interopNamespace(tunnel);
|
|
var FormData__default = _interopDefaultLegacy(FormData);
|
|
var node_fetch__default = _interopDefaultLegacy(node_fetch);
|
|
|
|
class HttpHeaders {
|
|
constructor(rawHeaders) {
|
|
this._headersMap = {};
|
|
if (rawHeaders)
|
|
for (const headerName in rawHeaders)
|
|
this.set(headerName, rawHeaders[headerName]);
|
|
}
|
|
set(headerName, headerValue) {
|
|
this._headersMap[getHeaderKey(headerName)] = {
|
|
name: headerName,
|
|
value: headerValue.toString()
|
|
};
|
|
}
|
|
get(headerName) {
|
|
const header = this._headersMap[getHeaderKey(headerName)];
|
|
return !header ? undefined : header.value;
|
|
}
|
|
contains(headerName) {
|
|
return !!this._headersMap[getHeaderKey(headerName)];
|
|
}
|
|
remove(headerName) {
|
|
const result = this.contains(headerName);
|
|
delete this._headersMap[getHeaderKey(headerName)];
|
|
return result;
|
|
}
|
|
rawHeaders() {
|
|
return this.toJson({ preserveCase: true });
|
|
}
|
|
headersArray() {
|
|
const headers = [];
|
|
for (const headerKey in this._headersMap)
|
|
headers.push(this._headersMap[headerKey]);
|
|
return headers;
|
|
}
|
|
headerNames() {
|
|
const headerNames = [];
|
|
const headers = this.headersArray();
|
|
for (let i = 0;i < headers.length; ++i)
|
|
headerNames.push(headers[i].name);
|
|
return headerNames;
|
|
}
|
|
headerValues() {
|
|
const headerValues = [];
|
|
const headers = this.headersArray();
|
|
for (let i = 0;i < headers.length; ++i)
|
|
headerValues.push(headers[i].value);
|
|
return headerValues;
|
|
}
|
|
toJson(options = {}) {
|
|
const result = {};
|
|
if (options.preserveCase)
|
|
for (const headerKey in this._headersMap) {
|
|
const header = this._headersMap[headerKey];
|
|
result[header.name] = header.value;
|
|
}
|
|
else
|
|
for (const headerKey in this._headersMap) {
|
|
const header = this._headersMap[headerKey];
|
|
result[getHeaderKey(header.name)] = header.value;
|
|
}
|
|
return result;
|
|
}
|
|
toString() {
|
|
return JSON.stringify(this.toJson({ preserveCase: true }));
|
|
}
|
|
clone() {
|
|
const resultPreservingCasing = {};
|
|
for (const headerKey in this._headersMap) {
|
|
const header = this._headersMap[headerKey];
|
|
resultPreservingCasing[header.name] = header.value;
|
|
}
|
|
return new HttpHeaders(resultPreservingCasing);
|
|
}
|
|
}
|
|
var Constants = {
|
|
coreHttpVersion: "3.0.1",
|
|
HTTP: "http:",
|
|
HTTPS: "https:",
|
|
HTTP_PROXY: "HTTP_PROXY",
|
|
HTTPS_PROXY: "HTTPS_PROXY",
|
|
NO_PROXY: "NO_PROXY",
|
|
ALL_PROXY: "ALL_PROXY",
|
|
HttpConstants: {
|
|
HttpVerbs: {
|
|
PUT: "PUT",
|
|
GET: "GET",
|
|
DELETE: "DELETE",
|
|
POST: "POST",
|
|
MERGE: "MERGE",
|
|
HEAD: "HEAD",
|
|
PATCH: "PATCH"
|
|
},
|
|
StatusCodes: {
|
|
TooManyRequests: 429,
|
|
ServiceUnavailable: 503
|
|
}
|
|
},
|
|
HeaderConstants: {
|
|
AUTHORIZATION: "authorization",
|
|
AUTHORIZATION_SCHEME: "Bearer",
|
|
RETRY_AFTER: "Retry-After",
|
|
USER_AGENT: "User-Agent"
|
|
}
|
|
};
|
|
var XML_ATTRKEY = "$";
|
|
var XML_CHARKEY = "_";
|
|
var validUuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
|
|
var isNode = typeof process !== "undefined" && !!process.version && !!process.versions && !!process.versions.node;
|
|
var validateISODuration = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
|
|
|
|
class Serializer {
|
|
constructor(modelMappers = {}, isXML) {
|
|
this.modelMappers = modelMappers;
|
|
this.isXML = isXML;
|
|
}
|
|
validateConstraints(mapper, value, objectName) {
|
|
const failValidation = (constraintName, constraintValue) => {
|
|
throw new Error(`"${objectName}" with value "${value}" should satisfy the constraint "${constraintName}": ${constraintValue}.`);
|
|
};
|
|
if (mapper.constraints && value != null) {
|
|
const valueAsNumber = value;
|
|
const { ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern, UniqueItems } = mapper.constraints;
|
|
if (ExclusiveMaximum != null && valueAsNumber >= ExclusiveMaximum)
|
|
failValidation("ExclusiveMaximum", ExclusiveMaximum);
|
|
if (ExclusiveMinimum != null && valueAsNumber <= ExclusiveMinimum)
|
|
failValidation("ExclusiveMinimum", ExclusiveMinimum);
|
|
if (InclusiveMaximum != null && valueAsNumber > InclusiveMaximum)
|
|
failValidation("InclusiveMaximum", InclusiveMaximum);
|
|
if (InclusiveMinimum != null && valueAsNumber < InclusiveMinimum)
|
|
failValidation("InclusiveMinimum", InclusiveMinimum);
|
|
const valueAsArray = value;
|
|
if (MaxItems != null && valueAsArray.length > MaxItems)
|
|
failValidation("MaxItems", MaxItems);
|
|
if (MaxLength != null && valueAsArray.length > MaxLength)
|
|
failValidation("MaxLength", MaxLength);
|
|
if (MinItems != null && valueAsArray.length < MinItems)
|
|
failValidation("MinItems", MinItems);
|
|
if (MinLength != null && valueAsArray.length < MinLength)
|
|
failValidation("MinLength", MinLength);
|
|
if (MultipleOf != null && valueAsNumber % MultipleOf !== 0)
|
|
failValidation("MultipleOf", MultipleOf);
|
|
if (Pattern) {
|
|
const pattern = typeof Pattern === "string" ? new RegExp(Pattern) : Pattern;
|
|
if (typeof value !== "string" || value.match(pattern) === null)
|
|
failValidation("Pattern", Pattern);
|
|
}
|
|
if (UniqueItems && valueAsArray.some((item, i, ar) => ar.indexOf(item) !== i))
|
|
failValidation("UniqueItems", UniqueItems);
|
|
}
|
|
}
|
|
serialize(mapper, object, objectName, options = {}) {
|
|
var _a, _b, _c;
|
|
const updatedOptions = {
|
|
rootName: (_a = options.rootName) !== null && _a !== undefined ? _a : "",
|
|
includeRoot: (_b = options.includeRoot) !== null && _b !== undefined ? _b : false,
|
|
xmlCharKey: (_c = options.xmlCharKey) !== null && _c !== undefined ? _c : XML_CHARKEY
|
|
};
|
|
let payload = {};
|
|
const mapperType = mapper.type.name;
|
|
if (!objectName)
|
|
objectName = mapper.serializedName;
|
|
if (mapperType.match(/^Sequence$/i) !== null)
|
|
payload = [];
|
|
if (mapper.isConstant)
|
|
object = mapper.defaultValue;
|
|
const { required, nullable } = mapper;
|
|
if (required && nullable && object === undefined)
|
|
throw new Error(`${objectName} cannot be undefined.`);
|
|
if (required && !nullable && object == undefined)
|
|
throw new Error(`${objectName} cannot be null or undefined.`);
|
|
if (!required && nullable === false && object === null)
|
|
throw new Error(`${objectName} cannot be null.`);
|
|
if (object == undefined)
|
|
payload = object;
|
|
else if (mapperType.match(/^any$/i) !== null)
|
|
payload = object;
|
|
else if (mapperType.match(/^(Number|String|Boolean|Object|Stream|Uuid)$/i) !== null)
|
|
payload = serializeBasicTypes(mapperType, objectName, object);
|
|
else if (mapperType.match(/^Enum$/i) !== null) {
|
|
const enumMapper = mapper;
|
|
payload = serializeEnumType(objectName, enumMapper.type.allowedValues, object);
|
|
} else if (mapperType.match(/^(Date|DateTime|TimeSpan|DateTimeRfc1123|UnixTime)$/i) !== null)
|
|
payload = serializeDateTypes(mapperType, object, objectName);
|
|
else if (mapperType.match(/^ByteArray$/i) !== null)
|
|
payload = serializeByteArrayType(objectName, object);
|
|
else if (mapperType.match(/^Base64Url$/i) !== null)
|
|
payload = serializeBase64UrlType(objectName, object);
|
|
else if (mapperType.match(/^Sequence$/i) !== null)
|
|
payload = serializeSequenceType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
|
|
else if (mapperType.match(/^Dictionary$/i) !== null)
|
|
payload = serializeDictionaryType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
|
|
else if (mapperType.match(/^Composite$/i) !== null)
|
|
payload = serializeCompositeType(this, mapper, object, objectName, Boolean(this.isXML), updatedOptions);
|
|
return payload;
|
|
}
|
|
deserialize(mapper, responseBody, objectName, options = {}) {
|
|
var _a, _b, _c;
|
|
const updatedOptions = {
|
|
rootName: (_a = options.rootName) !== null && _a !== undefined ? _a : "",
|
|
includeRoot: (_b = options.includeRoot) !== null && _b !== undefined ? _b : false,
|
|
xmlCharKey: (_c = options.xmlCharKey) !== null && _c !== undefined ? _c : XML_CHARKEY
|
|
};
|
|
if (responseBody == undefined) {
|
|
if (this.isXML && mapper.type.name === "Sequence" && !mapper.xmlIsWrapped)
|
|
responseBody = [];
|
|
if (mapper.defaultValue !== undefined)
|
|
responseBody = mapper.defaultValue;
|
|
return responseBody;
|
|
}
|
|
let payload;
|
|
const mapperType = mapper.type.name;
|
|
if (!objectName)
|
|
objectName = mapper.serializedName;
|
|
if (mapperType.match(/^Composite$/i) !== null)
|
|
payload = deserializeCompositeType(this, mapper, responseBody, objectName, updatedOptions);
|
|
else {
|
|
if (this.isXML) {
|
|
const xmlCharKey = updatedOptions.xmlCharKey;
|
|
const castResponseBody = responseBody;
|
|
if (castResponseBody[XML_ATTRKEY] != null && castResponseBody[xmlCharKey] != null)
|
|
responseBody = castResponseBody[xmlCharKey];
|
|
}
|
|
if (mapperType.match(/^Number$/i) !== null) {
|
|
payload = parseFloat(responseBody);
|
|
if (isNaN(payload))
|
|
payload = responseBody;
|
|
} else if (mapperType.match(/^Boolean$/i) !== null)
|
|
if (responseBody === "true")
|
|
payload = true;
|
|
else if (responseBody === "false")
|
|
payload = false;
|
|
else
|
|
payload = responseBody;
|
|
else if (mapperType.match(/^(String|Enum|Object|Stream|Uuid|TimeSpan|any)$/i) !== null)
|
|
payload = responseBody;
|
|
else if (mapperType.match(/^(Date|DateTime|DateTimeRfc1123)$/i) !== null)
|
|
payload = new Date(responseBody);
|
|
else if (mapperType.match(/^UnixTime$/i) !== null)
|
|
payload = unixTimeToDate(responseBody);
|
|
else if (mapperType.match(/^ByteArray$/i) !== null)
|
|
payload = decodeString(responseBody);
|
|
else if (mapperType.match(/^Base64Url$/i) !== null)
|
|
payload = base64UrlToByteArray(responseBody);
|
|
else if (mapperType.match(/^Sequence$/i) !== null)
|
|
payload = deserializeSequenceType(this, mapper, responseBody, objectName, updatedOptions);
|
|
else if (mapperType.match(/^Dictionary$/i) !== null)
|
|
payload = deserializeDictionaryType(this, mapper, responseBody, objectName, updatedOptions);
|
|
}
|
|
if (mapper.isConstant)
|
|
payload = mapper.defaultValue;
|
|
return payload;
|
|
}
|
|
}
|
|
var MapperType = strEnum([
|
|
"Base64Url",
|
|
"Boolean",
|
|
"ByteArray",
|
|
"Composite",
|
|
"Date",
|
|
"DateTime",
|
|
"DateTimeRfc1123",
|
|
"Dictionary",
|
|
"Enum",
|
|
"Number",
|
|
"Object",
|
|
"Sequence",
|
|
"String",
|
|
"Stream",
|
|
"TimeSpan",
|
|
"UnixTime"
|
|
]);
|
|
|
|
class WebResource {
|
|
constructor(url, method, body, query, headers, streamResponseBody, withCredentials, abortSignal, timeout, onUploadProgress, onDownloadProgress, proxySettings, keepAlive, decompressResponse, streamResponseStatusCodes) {
|
|
this.streamResponseBody = streamResponseBody;
|
|
this.streamResponseStatusCodes = streamResponseStatusCodes;
|
|
this.url = url || "";
|
|
this.method = method || "GET";
|
|
this.headers = isHttpHeadersLike(headers) ? headers : new HttpHeaders(headers);
|
|
this.body = body;
|
|
this.query = query;
|
|
this.formData = undefined;
|
|
this.withCredentials = withCredentials || false;
|
|
this.abortSignal = abortSignal;
|
|
this.timeout = timeout || 0;
|
|
this.onUploadProgress = onUploadProgress;
|
|
this.onDownloadProgress = onDownloadProgress;
|
|
this.proxySettings = proxySettings;
|
|
this.keepAlive = keepAlive;
|
|
this.decompressResponse = decompressResponse;
|
|
this.requestId = this.headers.get("x-ms-client-request-id") || generateUuid();
|
|
}
|
|
validateRequestProperties() {
|
|
if (!this.method)
|
|
throw new Error("WebResource.method is required.");
|
|
if (!this.url)
|
|
throw new Error("WebResource.url is required.");
|
|
}
|
|
prepare(options) {
|
|
if (!options)
|
|
throw new Error("options object is required");
|
|
if (options.method === undefined || options.method === null || typeof options.method.valueOf() !== "string")
|
|
throw new Error("options.method must be a string.");
|
|
if (options.url && options.pathTemplate)
|
|
throw new Error("options.url and options.pathTemplate are mutually exclusive. Please provide exactly one of them.");
|
|
if ((options.pathTemplate === undefined || options.pathTemplate === null || typeof options.pathTemplate.valueOf() !== "string") && (options.url === undefined || options.url === null || typeof options.url.valueOf() !== "string"))
|
|
throw new Error("Please provide exactly one of options.pathTemplate or options.url.");
|
|
if (options.url) {
|
|
if (typeof options.url !== "string")
|
|
throw new Error('options.url must be of type "string".');
|
|
this.url = options.url;
|
|
}
|
|
if (options.method) {
|
|
const validMethods = ["GET", "PUT", "HEAD", "DELETE", "OPTIONS", "POST", "PATCH", "TRACE"];
|
|
if (validMethods.indexOf(options.method.toUpperCase()) === -1)
|
|
throw new Error('The provided method "' + options.method + '" is invalid. Supported HTTP methods are: ' + JSON.stringify(validMethods));
|
|
}
|
|
this.method = options.method.toUpperCase();
|
|
if (options.pathTemplate) {
|
|
const { pathTemplate, pathParameters } = options;
|
|
if (typeof pathTemplate !== "string")
|
|
throw new Error('options.pathTemplate must be of type "string".');
|
|
if (!options.baseUrl)
|
|
options.baseUrl = "https://management.azure.com";
|
|
const baseUrl = options.baseUrl;
|
|
let url = baseUrl + (baseUrl.endsWith("/") ? "" : "/") + (pathTemplate.startsWith("/") ? pathTemplate.slice(1) : pathTemplate);
|
|
const segments = url.match(/({[\w-]*\s*[\w-]*})/gi);
|
|
if (segments && segments.length) {
|
|
if (!pathParameters)
|
|
throw new Error(`pathTemplate: ${pathTemplate} has been provided. Hence, options.pathParameters must also be provided.`);
|
|
segments.forEach(function(item) {
|
|
const pathParamName = item.slice(1, -1);
|
|
const pathParam = pathParameters[pathParamName];
|
|
if (pathParam === null || pathParam === undefined || !(typeof pathParam === "string" || typeof pathParam === "object")) {
|
|
const stringifiedPathParameters = JSON.stringify(pathParameters, undefined, 2);
|
|
throw new Error(`pathTemplate: ${pathTemplate} contains the path parameter ${pathParamName}` + ` however, it is not present in parameters: ${stringifiedPathParameters}.` + `The value of the path parameter can either be a "string" of the form { ${pathParamName}: "some sample value" } or ` + `it can be an "object" of the form { "${pathParamName}": { value: "some sample value", skipUrlEncoding: true } }.`);
|
|
}
|
|
if (typeof pathParam.valueOf() === "string")
|
|
url = url.replace(item, encodeURIComponent(pathParam));
|
|
if (typeof pathParam.valueOf() === "object") {
|
|
if (!pathParam.value)
|
|
throw new Error(`options.pathParameters[${pathParamName}] is of type "object" but it does not contain a "value" property.`);
|
|
if (pathParam.skipUrlEncoding)
|
|
url = url.replace(item, pathParam.value);
|
|
else
|
|
url = url.replace(item, encodeURIComponent(pathParam.value));
|
|
}
|
|
});
|
|
}
|
|
this.url = url;
|
|
}
|
|
if (options.queryParameters) {
|
|
const queryParameters = options.queryParameters;
|
|
if (typeof queryParameters !== "object")
|
|
throw new Error(`options.queryParameters must be of type object. It should be a JSON object of "query-parameter-name" as the key and the "query-parameter-value" as the value. The "query-parameter-value" may be fo type "string" or an "object" of the form { value: "query-parameter-value", skipUrlEncoding: true }.`);
|
|
if (this.url && this.url.indexOf("?") === -1)
|
|
this.url += "?";
|
|
const queryParams = [];
|
|
this.query = {};
|
|
for (const queryParamName in queryParameters) {
|
|
const queryParam = queryParameters[queryParamName];
|
|
if (queryParam) {
|
|
if (typeof queryParam === "string") {
|
|
queryParams.push(queryParamName + "=" + encodeURIComponent(queryParam));
|
|
this.query[queryParamName] = encodeURIComponent(queryParam);
|
|
} else if (typeof queryParam === "object") {
|
|
if (!queryParam.value)
|
|
throw new Error(`options.queryParameters[${queryParamName}] is of type "object" but it does not contain a "value" property.`);
|
|
if (queryParam.skipUrlEncoding) {
|
|
queryParams.push(queryParamName + "=" + queryParam.value);
|
|
this.query[queryParamName] = queryParam.value;
|
|
} else {
|
|
queryParams.push(queryParamName + "=" + encodeURIComponent(queryParam.value));
|
|
this.query[queryParamName] = encodeURIComponent(queryParam.value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.url += queryParams.join("&");
|
|
}
|
|
if (options.headers) {
|
|
const headers = options.headers;
|
|
for (const headerName of Object.keys(options.headers))
|
|
this.headers.set(headerName, headers[headerName]);
|
|
}
|
|
if (!this.headers.get("accept-language"))
|
|
this.headers.set("accept-language", "en-US");
|
|
if (!this.headers.get("x-ms-client-request-id") && !options.disableClientRequestId)
|
|
this.headers.set("x-ms-client-request-id", this.requestId);
|
|
if (!this.headers.get("Content-Type"))
|
|
this.headers.set("Content-Type", "application/json; charset=utf-8");
|
|
this.body = options.body;
|
|
if (options.body !== undefined && options.body !== null)
|
|
if (options.bodyIsStream) {
|
|
if (!this.headers.get("Transfer-Encoding"))
|
|
this.headers.set("Transfer-Encoding", "chunked");
|
|
if (this.headers.get("Content-Type") !== "application/octet-stream")
|
|
this.headers.set("Content-Type", "application/octet-stream");
|
|
} else {
|
|
if (options.serializationMapper)
|
|
this.body = new Serializer(options.mappers).serialize(options.serializationMapper, options.body, "requestBody");
|
|
if (!options.disableJsonStringifyOnBody)
|
|
this.body = JSON.stringify(options.body);
|
|
}
|
|
if (options.spanOptions)
|
|
this.spanOptions = options.spanOptions;
|
|
if (options.tracingContext)
|
|
this.tracingContext = options.tracingContext;
|
|
this.abortSignal = options.abortSignal;
|
|
this.onDownloadProgress = options.onDownloadProgress;
|
|
this.onUploadProgress = options.onUploadProgress;
|
|
return this;
|
|
}
|
|
clone() {
|
|
const result = new WebResource(this.url, this.method, this.body, this.query, this.headers && this.headers.clone(), this.streamResponseBody, this.withCredentials, this.abortSignal, this.timeout, this.onUploadProgress, this.onDownloadProgress, this.proxySettings, this.keepAlive, this.decompressResponse, this.streamResponseStatusCodes);
|
|
if (this.formData)
|
|
result.formData = this.formData;
|
|
if (this.operationSpec)
|
|
result.operationSpec = this.operationSpec;
|
|
if (this.shouldDeserialize)
|
|
result.shouldDeserialize = this.shouldDeserialize;
|
|
if (this.operationResponseGetter)
|
|
result.operationResponseGetter = this.operationResponseGetter;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class URLQuery {
|
|
constructor() {
|
|
this._rawQuery = {};
|
|
}
|
|
any() {
|
|
return Object.keys(this._rawQuery).length > 0;
|
|
}
|
|
keys() {
|
|
return Object.keys(this._rawQuery);
|
|
}
|
|
set(parameterName, parameterValue) {
|
|
const caseParameterValue = parameterValue;
|
|
if (parameterName)
|
|
if (caseParameterValue !== undefined && caseParameterValue !== null) {
|
|
const newValue = Array.isArray(caseParameterValue) ? caseParameterValue : caseParameterValue.toString();
|
|
this._rawQuery[parameterName] = newValue;
|
|
} else
|
|
delete this._rawQuery[parameterName];
|
|
}
|
|
get(parameterName) {
|
|
return parameterName ? this._rawQuery[parameterName] : undefined;
|
|
}
|
|
toString() {
|
|
let result = "";
|
|
for (const parameterName in this._rawQuery) {
|
|
if (result)
|
|
result += "&";
|
|
const parameterValue = this._rawQuery[parameterName];
|
|
if (Array.isArray(parameterValue)) {
|
|
const parameterStrings = [];
|
|
for (const parameterValueElement of parameterValue)
|
|
parameterStrings.push(`${parameterName}=${parameterValueElement}`);
|
|
result += parameterStrings.join("&");
|
|
} else
|
|
result += `${parameterName}=${parameterValue}`;
|
|
}
|
|
return result;
|
|
}
|
|
static parse(text) {
|
|
const result = new URLQuery;
|
|
if (text) {
|
|
if (text.startsWith("?"))
|
|
text = text.substring(1);
|
|
let currentState = "ParameterName";
|
|
let parameterName = "";
|
|
let parameterValue = "";
|
|
for (let i = 0;i < text.length; ++i) {
|
|
const currentCharacter = text[i];
|
|
switch (currentState) {
|
|
case "ParameterName":
|
|
switch (currentCharacter) {
|
|
case "=":
|
|
currentState = "ParameterValue";
|
|
break;
|
|
case "&":
|
|
parameterName = "";
|
|
parameterValue = "";
|
|
break;
|
|
default:
|
|
parameterName += currentCharacter;
|
|
break;
|
|
}
|
|
break;
|
|
case "ParameterValue":
|
|
switch (currentCharacter) {
|
|
case "&":
|
|
result.set(parameterName, parameterValue);
|
|
parameterName = "";
|
|
parameterValue = "";
|
|
currentState = "ParameterName";
|
|
break;
|
|
default:
|
|
parameterValue += currentCharacter;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error("Unrecognized URLQuery parse state: " + currentState);
|
|
}
|
|
}
|
|
if (currentState === "ParameterValue")
|
|
result.set(parameterName, parameterValue);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class URLBuilder {
|
|
setScheme(scheme) {
|
|
if (!scheme)
|
|
this._scheme = undefined;
|
|
else
|
|
this.set(scheme, "SCHEME");
|
|
}
|
|
getScheme() {
|
|
return this._scheme;
|
|
}
|
|
setHost(host) {
|
|
if (!host)
|
|
this._host = undefined;
|
|
else
|
|
this.set(host, "SCHEME_OR_HOST");
|
|
}
|
|
getHost() {
|
|
return this._host;
|
|
}
|
|
setPort(port) {
|
|
if (port === undefined || port === null || port === "")
|
|
this._port = undefined;
|
|
else
|
|
this.set(port.toString(), "PORT");
|
|
}
|
|
getPort() {
|
|
return this._port;
|
|
}
|
|
setPath(path) {
|
|
if (!path)
|
|
this._path = undefined;
|
|
else {
|
|
const schemeIndex = path.indexOf("://");
|
|
if (schemeIndex !== -1) {
|
|
const schemeStart = path.lastIndexOf("/", schemeIndex);
|
|
this.set(schemeStart === -1 ? path : path.substr(schemeStart + 1), "SCHEME");
|
|
} else
|
|
this.set(path, "PATH");
|
|
}
|
|
}
|
|
appendPath(path) {
|
|
if (path) {
|
|
let currentPath = this.getPath();
|
|
if (currentPath) {
|
|
if (!currentPath.endsWith("/"))
|
|
currentPath += "/";
|
|
if (path.startsWith("/"))
|
|
path = path.substring(1);
|
|
path = currentPath + path;
|
|
}
|
|
this.set(path, "PATH");
|
|
}
|
|
}
|
|
getPath() {
|
|
return this._path;
|
|
}
|
|
setQuery(query) {
|
|
if (!query)
|
|
this._query = undefined;
|
|
else
|
|
this._query = URLQuery.parse(query);
|
|
}
|
|
setQueryParameter(queryParameterName, queryParameterValue) {
|
|
if (queryParameterName) {
|
|
if (!this._query)
|
|
this._query = new URLQuery;
|
|
this._query.set(queryParameterName, queryParameterValue);
|
|
}
|
|
}
|
|
getQueryParameterValue(queryParameterName) {
|
|
return this._query ? this._query.get(queryParameterName) : undefined;
|
|
}
|
|
getQuery() {
|
|
return this._query ? this._query.toString() : undefined;
|
|
}
|
|
set(text, startState) {
|
|
const tokenizer = new URLTokenizer(text, startState);
|
|
while (tokenizer.next()) {
|
|
const token = tokenizer.current();
|
|
let tokenPath;
|
|
if (token)
|
|
switch (token.type) {
|
|
case "SCHEME":
|
|
this._scheme = token.text || undefined;
|
|
break;
|
|
case "HOST":
|
|
this._host = token.text || undefined;
|
|
break;
|
|
case "PORT":
|
|
this._port = token.text || undefined;
|
|
break;
|
|
case "PATH":
|
|
tokenPath = token.text || undefined;
|
|
if (!this._path || this._path === "/" || tokenPath !== "/")
|
|
this._path = tokenPath;
|
|
break;
|
|
case "QUERY":
|
|
this._query = URLQuery.parse(token.text);
|
|
break;
|
|
default:
|
|
throw new Error(`Unrecognized URLTokenType: ${token.type}`);
|
|
}
|
|
}
|
|
}
|
|
toString() {
|
|
let result = "";
|
|
if (this._scheme)
|
|
result += `${this._scheme}://`;
|
|
if (this._host)
|
|
result += this._host;
|
|
if (this._port)
|
|
result += `:${this._port}`;
|
|
if (this._path) {
|
|
if (!this._path.startsWith("/"))
|
|
result += "/";
|
|
result += this._path;
|
|
}
|
|
if (this._query && this._query.any())
|
|
result += `?${this._query.toString()}`;
|
|
return result;
|
|
}
|
|
replaceAll(searchValue, replaceValue) {
|
|
if (searchValue) {
|
|
this.setScheme(replaceAll(this.getScheme(), searchValue, replaceValue));
|
|
this.setHost(replaceAll(this.getHost(), searchValue, replaceValue));
|
|
this.setPort(replaceAll(this.getPort(), searchValue, replaceValue));
|
|
this.setPath(replaceAll(this.getPath(), searchValue, replaceValue));
|
|
this.setQuery(replaceAll(this.getQuery(), searchValue, replaceValue));
|
|
}
|
|
}
|
|
static parse(text) {
|
|
const result = new URLBuilder;
|
|
result.set(text, "SCHEME_OR_HOST");
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class URLToken {
|
|
constructor(text, type) {
|
|
this.text = text;
|
|
this.type = type;
|
|
}
|
|
static scheme(text) {
|
|
return new URLToken(text, "SCHEME");
|
|
}
|
|
static host(text) {
|
|
return new URLToken(text, "HOST");
|
|
}
|
|
static port(text) {
|
|
return new URLToken(text, "PORT");
|
|
}
|
|
static path(text) {
|
|
return new URLToken(text, "PATH");
|
|
}
|
|
static query(text) {
|
|
return new URLToken(text, "QUERY");
|
|
}
|
|
}
|
|
|
|
class URLTokenizer {
|
|
constructor(_text, state) {
|
|
this._text = _text;
|
|
this._textLength = _text ? _text.length : 0;
|
|
this._currentState = state !== undefined && state !== null ? state : "SCHEME_OR_HOST";
|
|
this._currentIndex = 0;
|
|
}
|
|
current() {
|
|
return this._currentToken;
|
|
}
|
|
next() {
|
|
if (!hasCurrentCharacter(this))
|
|
this._currentToken = undefined;
|
|
else
|
|
switch (this._currentState) {
|
|
case "SCHEME":
|
|
nextScheme(this);
|
|
break;
|
|
case "SCHEME_OR_HOST":
|
|
nextSchemeOrHost(this);
|
|
break;
|
|
case "HOST":
|
|
nextHost(this);
|
|
break;
|
|
case "PORT":
|
|
nextPort(this);
|
|
break;
|
|
case "PATH":
|
|
nextPath(this);
|
|
break;
|
|
case "QUERY":
|
|
nextQuery(this);
|
|
break;
|
|
default:
|
|
throw new Error(`Unrecognized URLTokenizerState: ${this._currentState}`);
|
|
}
|
|
return !!this._currentToken;
|
|
}
|
|
}
|
|
var RedactedString = "REDACTED";
|
|
var defaultAllowedHeaderNames = [
|
|
"x-ms-client-request-id",
|
|
"x-ms-return-client-request-id",
|
|
"x-ms-useragent",
|
|
"x-ms-correlation-request-id",
|
|
"x-ms-request-id",
|
|
"client-request-id",
|
|
"ms-cv",
|
|
"return-client-request-id",
|
|
"traceparent",
|
|
"Access-Control-Allow-Credentials",
|
|
"Access-Control-Allow-Headers",
|
|
"Access-Control-Allow-Methods",
|
|
"Access-Control-Allow-Origin",
|
|
"Access-Control-Expose-Headers",
|
|
"Access-Control-Max-Age",
|
|
"Access-Control-Request-Headers",
|
|
"Access-Control-Request-Method",
|
|
"Origin",
|
|
"Accept",
|
|
"Accept-Encoding",
|
|
"Cache-Control",
|
|
"Connection",
|
|
"Content-Length",
|
|
"Content-Type",
|
|
"Date",
|
|
"ETag",
|
|
"Expires",
|
|
"If-Match",
|
|
"If-Modified-Since",
|
|
"If-None-Match",
|
|
"If-Unmodified-Since",
|
|
"Last-Modified",
|
|
"Pragma",
|
|
"Request-Id",
|
|
"Retry-After",
|
|
"Server",
|
|
"Transfer-Encoding",
|
|
"User-Agent",
|
|
"WWW-Authenticate"
|
|
];
|
|
var defaultAllowedQueryParameters = ["api-version"];
|
|
|
|
class Sanitizer {
|
|
constructor({ allowedHeaderNames = [], allowedQueryParameters = [] } = {}) {
|
|
allowedHeaderNames = Array.isArray(allowedHeaderNames) ? defaultAllowedHeaderNames.concat(allowedHeaderNames) : defaultAllowedHeaderNames;
|
|
allowedQueryParameters = Array.isArray(allowedQueryParameters) ? defaultAllowedQueryParameters.concat(allowedQueryParameters) : defaultAllowedQueryParameters;
|
|
this.allowedHeaderNames = new Set(allowedHeaderNames.map((n) => n.toLowerCase()));
|
|
this.allowedQueryParameters = new Set(allowedQueryParameters.map((p) => p.toLowerCase()));
|
|
}
|
|
sanitize(obj) {
|
|
const seen = new Set;
|
|
return JSON.stringify(obj, (key, value) => {
|
|
if (value instanceof Error)
|
|
return Object.assign(Object.assign({}, value), { name: value.name, message: value.message });
|
|
if (key === "_headersMap")
|
|
return this.sanitizeHeaders(value);
|
|
else if (key === "url")
|
|
return this.sanitizeUrl(value);
|
|
else if (key === "query")
|
|
return this.sanitizeQuery(value);
|
|
else if (key === "body")
|
|
return;
|
|
else if (key === "response")
|
|
return;
|
|
else if (key === "operationSpec")
|
|
return;
|
|
else if (Array.isArray(value) || isObject(value)) {
|
|
if (seen.has(value))
|
|
return "[Circular]";
|
|
seen.add(value);
|
|
}
|
|
return value;
|
|
}, 2);
|
|
}
|
|
sanitizeHeaders(value) {
|
|
return this.sanitizeObject(value, this.allowedHeaderNames, (v, k) => v[k].value);
|
|
}
|
|
sanitizeQuery(value) {
|
|
return this.sanitizeObject(value, this.allowedQueryParameters, (v, k) => v[k]);
|
|
}
|
|
sanitizeObject(value, allowedKeys, accessor) {
|
|
if (typeof value !== "object" || value === null)
|
|
return value;
|
|
const sanitized = {};
|
|
for (const k of Object.keys(value))
|
|
if (allowedKeys.has(k.toLowerCase()))
|
|
sanitized[k] = accessor(value, k);
|
|
else
|
|
sanitized[k] = RedactedString;
|
|
return sanitized;
|
|
}
|
|
sanitizeUrl(value) {
|
|
if (typeof value !== "string" || value === null)
|
|
return value;
|
|
const urlBuilder = URLBuilder.parse(value);
|
|
const queryString = urlBuilder.getQuery();
|
|
if (!queryString)
|
|
return value;
|
|
const query = URLQuery.parse(queryString);
|
|
for (const k of query.keys())
|
|
if (!this.allowedQueryParameters.has(k.toLowerCase()))
|
|
query.set(k, RedactedString);
|
|
urlBuilder.setQuery(query.toString());
|
|
return urlBuilder.toString();
|
|
}
|
|
}
|
|
var custom = util.inspect.custom;
|
|
var errorSanitizer = new Sanitizer;
|
|
|
|
class RestError extends Error {
|
|
constructor(message, code, statusCode, request, response) {
|
|
super(message);
|
|
this.name = "RestError";
|
|
this.code = code;
|
|
this.statusCode = statusCode;
|
|
this.request = request;
|
|
this.response = response;
|
|
Object.setPrototypeOf(this, RestError.prototype);
|
|
}
|
|
[custom]() {
|
|
return `RestError: ${this.message} \n ${errorSanitizer.sanitize(this)}`;
|
|
}
|
|
}
|
|
RestError.REQUEST_SEND_ERROR = "REQUEST_SEND_ERROR";
|
|
RestError.PARSE_ERROR = "PARSE_ERROR";
|
|
var logger = logger$1.createClientLogger("core-http");
|
|
|
|
class ReportTransform extends stream.Transform {
|
|
constructor(progressCallback) {
|
|
super();
|
|
this.progressCallback = progressCallback;
|
|
this.loadedBytes = 0;
|
|
}
|
|
_transform(chunk, _encoding, callback) {
|
|
this.push(chunk);
|
|
this.loadedBytes += chunk.length;
|
|
this.progressCallback({ loadedBytes: this.loadedBytes });
|
|
callback(undefined);
|
|
}
|
|
}
|
|
|
|
class NodeFetchHttpClient {
|
|
constructor() {
|
|
this.proxyAgentMap = new Map;
|
|
this.keepAliveAgents = {};
|
|
}
|
|
async sendRequest(httpRequest) {
|
|
var _a;
|
|
if (!httpRequest && typeof httpRequest !== "object")
|
|
throw new Error("'httpRequest' (WebResourceLike) cannot be null or undefined and must be of type object.");
|
|
const abortController$1 = new abortController.AbortController;
|
|
let abortListener;
|
|
if (httpRequest.abortSignal) {
|
|
if (httpRequest.abortSignal.aborted)
|
|
throw new abortController.AbortError("The operation was aborted.");
|
|
abortListener = (event) => {
|
|
if (event.type === "abort")
|
|
abortController$1.abort();
|
|
};
|
|
httpRequest.abortSignal.addEventListener("abort", abortListener);
|
|
}
|
|
if (httpRequest.timeout)
|
|
setTimeout(() => {
|
|
abortController$1.abort();
|
|
}, httpRequest.timeout);
|
|
if (httpRequest.formData) {
|
|
const formData = httpRequest.formData;
|
|
const requestForm = new FormData__default["default"];
|
|
const appendFormValue = (key, value) => {
|
|
if (typeof value === "function")
|
|
value = value();
|
|
if (value && Object.prototype.hasOwnProperty.call(value, "value") && Object.prototype.hasOwnProperty.call(value, "options"))
|
|
requestForm.append(key, value.value, value.options);
|
|
else
|
|
requestForm.append(key, value);
|
|
};
|
|
for (const formKey of Object.keys(formData)) {
|
|
const formValue = formData[formKey];
|
|
if (Array.isArray(formValue))
|
|
for (let j = 0;j < formValue.length; j++)
|
|
appendFormValue(formKey, formValue[j]);
|
|
else
|
|
appendFormValue(formKey, formValue);
|
|
}
|
|
httpRequest.body = requestForm;
|
|
httpRequest.formData = undefined;
|
|
const contentType = httpRequest.headers.get("Content-Type");
|
|
if (contentType && contentType.indexOf("multipart/form-data") !== -1)
|
|
if (typeof requestForm.getBoundary === "function")
|
|
httpRequest.headers.set("Content-Type", `multipart/form-data; boundary=${requestForm.getBoundary()}`);
|
|
else
|
|
httpRequest.headers.remove("Content-Type");
|
|
}
|
|
let body = httpRequest.body ? typeof httpRequest.body === "function" ? httpRequest.body() : httpRequest.body : undefined;
|
|
if (httpRequest.onUploadProgress && httpRequest.body) {
|
|
const onUploadProgress = httpRequest.onUploadProgress;
|
|
const uploadReportStream = new ReportTransform(onUploadProgress);
|
|
if (isReadableStream(body))
|
|
body.pipe(uploadReportStream);
|
|
else
|
|
uploadReportStream.end(body);
|
|
body = uploadReportStream;
|
|
}
|
|
const platformSpecificRequestInit = await this.prepareRequest(httpRequest);
|
|
const requestInit = Object.assign({
|
|
body,
|
|
headers: httpRequest.headers.rawHeaders(),
|
|
method: httpRequest.method,
|
|
signal: abortController$1.signal,
|
|
redirect: "manual"
|
|
}, platformSpecificRequestInit);
|
|
let operationResponse;
|
|
try {
|
|
const response = await this.fetch(httpRequest.url, requestInit);
|
|
const headers = parseHeaders(response.headers);
|
|
const streaming = ((_a = httpRequest.streamResponseStatusCodes) === null || _a === undefined ? undefined : _a.has(response.status)) || httpRequest.streamResponseBody;
|
|
operationResponse = {
|
|
headers,
|
|
request: httpRequest,
|
|
status: response.status,
|
|
readableStreamBody: streaming ? response.body : undefined,
|
|
bodyAsText: !streaming ? await response.text() : undefined
|
|
};
|
|
const onDownloadProgress = httpRequest.onDownloadProgress;
|
|
if (onDownloadProgress) {
|
|
const responseBody = response.body || undefined;
|
|
if (isReadableStream(responseBody)) {
|
|
const downloadReportStream = new ReportTransform(onDownloadProgress);
|
|
responseBody.pipe(downloadReportStream);
|
|
operationResponse.readableStreamBody = downloadReportStream;
|
|
} else {
|
|
const length = parseInt(headers.get("Content-Length")) || undefined;
|
|
if (length)
|
|
onDownloadProgress({ loadedBytes: length });
|
|
}
|
|
}
|
|
await this.processRequest(operationResponse);
|
|
return operationResponse;
|
|
} catch (error) {
|
|
const fetchError = error;
|
|
if (fetchError.code === "ENOTFOUND")
|
|
throw new RestError(fetchError.message, RestError.REQUEST_SEND_ERROR, undefined, httpRequest);
|
|
else if (fetchError.type === "aborted")
|
|
throw new abortController.AbortError("The operation was aborted.");
|
|
throw fetchError;
|
|
} finally {
|
|
if (httpRequest.abortSignal && abortListener) {
|
|
let uploadStreamDone = Promise.resolve();
|
|
if (isReadableStream(body))
|
|
uploadStreamDone = isStreamComplete(body);
|
|
let downloadStreamDone = Promise.resolve();
|
|
if (isReadableStream(operationResponse === null || operationResponse === undefined ? undefined : operationResponse.readableStreamBody))
|
|
downloadStreamDone = isStreamComplete(operationResponse.readableStreamBody, abortController$1);
|
|
Promise.all([uploadStreamDone, downloadStreamDone]).then(() => {
|
|
var _a2;
|
|
(_a2 = httpRequest.abortSignal) === null || _a2 === undefined || _a2.removeEventListener("abort", abortListener);
|
|
return;
|
|
}).catch((e) => {
|
|
logger.warning("Error when cleaning up abortListener on httpRequest", e);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
getOrCreateAgent(httpRequest) {
|
|
var _a;
|
|
const isHttps = isUrlHttps(httpRequest.url);
|
|
if (httpRequest.proxySettings) {
|
|
const { host, port, username, password } = httpRequest.proxySettings;
|
|
const key = `${host}:${port}:${username}:${password}`;
|
|
const proxyAgents = (_a = this.proxyAgentMap.get(key)) !== null && _a !== undefined ? _a : {};
|
|
let agent = getCachedAgent(isHttps, proxyAgents);
|
|
if (agent)
|
|
return agent;
|
|
const tunnel2 = createProxyAgent(httpRequest.url, httpRequest.proxySettings, httpRequest.headers);
|
|
agent = tunnel2.agent;
|
|
if (tunnel2.isHttps)
|
|
proxyAgents.httpsAgent = tunnel2.agent;
|
|
else
|
|
proxyAgents.httpAgent = tunnel2.agent;
|
|
this.proxyAgentMap.set(key, proxyAgents);
|
|
return agent;
|
|
} else if (httpRequest.keepAlive) {
|
|
let agent = getCachedAgent(isHttps, this.keepAliveAgents);
|
|
if (agent)
|
|
return agent;
|
|
const agentOptions = {
|
|
keepAlive: httpRequest.keepAlive
|
|
};
|
|
if (isHttps)
|
|
agent = this.keepAliveAgents.httpsAgent = new https__namespace.Agent(agentOptions);
|
|
else
|
|
agent = this.keepAliveAgents.httpAgent = new http__namespace.Agent(agentOptions);
|
|
return agent;
|
|
} else
|
|
return isHttps ? https__namespace.globalAgent : http__namespace.globalAgent;
|
|
}
|
|
async fetch(input, init) {
|
|
return node_fetch__default["default"](input, init);
|
|
}
|
|
async prepareRequest(httpRequest) {
|
|
const requestInit = {};
|
|
requestInit.agent = this.getOrCreateAgent(httpRequest);
|
|
requestInit.compress = httpRequest.decompressResponse;
|
|
return requestInit;
|
|
}
|
|
async processRequest(_operationResponse) {
|
|
}
|
|
}
|
|
exports.HttpPipelineLogLevel = undefined;
|
|
(function(HttpPipelineLogLevel) {
|
|
HttpPipelineLogLevel[HttpPipelineLogLevel["OFF"] = 0] = "OFF";
|
|
HttpPipelineLogLevel[HttpPipelineLogLevel["ERROR"] = 1] = "ERROR";
|
|
HttpPipelineLogLevel[HttpPipelineLogLevel["WARNING"] = 2] = "WARNING";
|
|
HttpPipelineLogLevel[HttpPipelineLogLevel["INFO"] = 3] = "INFO";
|
|
})(exports.HttpPipelineLogLevel || (exports.HttpPipelineLogLevel = {}));
|
|
|
|
class BaseRequestPolicy {
|
|
constructor(_nextPolicy, _options) {
|
|
this._nextPolicy = _nextPolicy;
|
|
this._options = _options;
|
|
}
|
|
shouldLog(logLevel) {
|
|
return this._options.shouldLog(logLevel);
|
|
}
|
|
log(logLevel, message) {
|
|
this._options.log(logLevel, message);
|
|
}
|
|
}
|
|
|
|
class RequestPolicyOptions {
|
|
constructor(_logger) {
|
|
this._logger = _logger;
|
|
}
|
|
shouldLog(logLevel) {
|
|
return !!this._logger && logLevel !== exports.HttpPipelineLogLevel.OFF && logLevel <= this._logger.minimumLogLevel;
|
|
}
|
|
log(logLevel, message) {
|
|
if (this._logger && this.shouldLog(logLevel))
|
|
this._logger.log(logLevel, message);
|
|
}
|
|
}
|
|
var xml2jsDefaultOptionsV2 = {
|
|
explicitCharkey: false,
|
|
trim: false,
|
|
normalize: false,
|
|
normalizeTags: false,
|
|
attrkey: XML_ATTRKEY,
|
|
explicitArray: true,
|
|
ignoreAttrs: false,
|
|
mergeAttrs: false,
|
|
explicitRoot: true,
|
|
validator: undefined,
|
|
xmlns: false,
|
|
explicitChildren: false,
|
|
preserveChildrenOrder: false,
|
|
childkey: "$$",
|
|
charsAsChildren: false,
|
|
includeWhiteChars: false,
|
|
async: false,
|
|
strict: true,
|
|
attrNameProcessors: undefined,
|
|
attrValueProcessors: undefined,
|
|
tagNameProcessors: undefined,
|
|
valueProcessors: undefined,
|
|
rootName: "root",
|
|
xmldec: {
|
|
version: "1.0",
|
|
encoding: "UTF-8",
|
|
standalone: true
|
|
},
|
|
doctype: undefined,
|
|
renderOpts: {
|
|
pretty: true,
|
|
indent: " ",
|
|
newline: "\n"
|
|
},
|
|
headless: false,
|
|
chunkSize: 1e4,
|
|
emptyTag: "",
|
|
cdata: false
|
|
};
|
|
var xml2jsParserSettings = Object.assign({}, xml2jsDefaultOptionsV2);
|
|
xml2jsParserSettings.explicitArray = false;
|
|
var xml2jsBuilderSettings = Object.assign({}, xml2jsDefaultOptionsV2);
|
|
xml2jsBuilderSettings.explicitArray = false;
|
|
xml2jsBuilderSettings.renderOpts = {
|
|
pretty: false
|
|
};
|
|
var defaultJsonContentTypes = ["application/json", "text/json"];
|
|
var defaultXmlContentTypes = ["application/xml", "application/atom+xml"];
|
|
var DefaultDeserializationOptions = {
|
|
expectedContentTypes: {
|
|
json: defaultJsonContentTypes,
|
|
xml: defaultXmlContentTypes
|
|
}
|
|
};
|
|
|
|
class DeserializationPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, requestPolicyOptions, deserializationContentTypes, parsingOptions = {}) {
|
|
var _a;
|
|
super(nextPolicy, requestPolicyOptions);
|
|
this.jsonContentTypes = deserializationContentTypes && deserializationContentTypes.json || defaultJsonContentTypes;
|
|
this.xmlContentTypes = deserializationContentTypes && deserializationContentTypes.xml || defaultXmlContentTypes;
|
|
this.xmlCharKey = (_a = parsingOptions.xmlCharKey) !== null && _a !== undefined ? _a : XML_CHARKEY;
|
|
}
|
|
async sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(request).then((response) => deserializeResponseBody(this.jsonContentTypes, this.xmlContentTypes, response, {
|
|
xmlCharKey: this.xmlCharKey
|
|
}));
|
|
}
|
|
}
|
|
var DefaultKeepAliveOptions = {
|
|
enable: true
|
|
};
|
|
|
|
class KeepAlivePolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, keepAliveOptions) {
|
|
super(nextPolicy, options);
|
|
this.keepAliveOptions = keepAliveOptions;
|
|
}
|
|
async sendRequest(request) {
|
|
request.keepAlive = this.keepAliveOptions.enable;
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
var allowedRedirect = ["GET", "HEAD"];
|
|
var DefaultRedirectOptions = {
|
|
handleRedirects: true,
|
|
maxRetries: 20
|
|
};
|
|
|
|
class RedirectPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, maxRetries = 20) {
|
|
super(nextPolicy, options);
|
|
this.maxRetries = maxRetries;
|
|
}
|
|
sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(request).then((response) => handleRedirect(this, response, 0));
|
|
}
|
|
}
|
|
var DEFAULT_CLIENT_RETRY_COUNT = 3;
|
|
var DEFAULT_CLIENT_RETRY_INTERVAL = 1000 * 30;
|
|
var DEFAULT_CLIENT_MAX_RETRY_INTERVAL = 1000 * 90;
|
|
var DEFAULT_CLIENT_MIN_RETRY_INTERVAL = 1000 * 3;
|
|
exports.RetryMode = undefined;
|
|
(function(RetryMode) {
|
|
RetryMode[RetryMode["Exponential"] = 0] = "Exponential";
|
|
})(exports.RetryMode || (exports.RetryMode = {}));
|
|
var DefaultRetryOptions = {
|
|
maxRetries: DEFAULT_CLIENT_RETRY_COUNT,
|
|
retryDelayInMs: DEFAULT_CLIENT_RETRY_INTERVAL,
|
|
maxRetryDelayInMs: DEFAULT_CLIENT_MAX_RETRY_INTERVAL
|
|
};
|
|
|
|
class ExponentialRetryPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, retryCount, retryInterval, maxRetryInterval) {
|
|
super(nextPolicy, options);
|
|
this.retryCount = isNumber(retryCount) ? retryCount : DEFAULT_CLIENT_RETRY_COUNT;
|
|
this.retryInterval = isNumber(retryInterval) ? retryInterval : DEFAULT_CLIENT_RETRY_INTERVAL;
|
|
this.maxRetryInterval = isNumber(maxRetryInterval) ? maxRetryInterval : DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
|
|
}
|
|
sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(request.clone()).then((response) => retry$1(this, request, response)).catch((error) => retry$1(this, request, error.response, undefined, error));
|
|
}
|
|
}
|
|
|
|
class LogPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, { logger: logger$12 = logger.info, allowedHeaderNames = [], allowedQueryParameters = [] } = {}) {
|
|
super(nextPolicy, options);
|
|
this.logger = logger$12;
|
|
this.sanitizer = new Sanitizer({ allowedHeaderNames, allowedQueryParameters });
|
|
}
|
|
get allowedHeaderNames() {
|
|
return this.sanitizer.allowedHeaderNames;
|
|
}
|
|
set allowedHeaderNames(allowedHeaderNames) {
|
|
this.sanitizer.allowedHeaderNames = allowedHeaderNames;
|
|
}
|
|
get allowedQueryParameters() {
|
|
return this.sanitizer.allowedQueryParameters;
|
|
}
|
|
set allowedQueryParameters(allowedQueryParameters) {
|
|
this.sanitizer.allowedQueryParameters = allowedQueryParameters;
|
|
}
|
|
sendRequest(request) {
|
|
if (!this.logger.enabled)
|
|
return this._nextPolicy.sendRequest(request);
|
|
this.logRequest(request);
|
|
return this._nextPolicy.sendRequest(request).then((response) => this.logResponse(response));
|
|
}
|
|
logRequest(request) {
|
|
this.logger(`Request: ${this.sanitizer.sanitize(request)}`);
|
|
}
|
|
logResponse(response) {
|
|
this.logger(`Response status code: ${response.status}`);
|
|
this.logger(`Headers: ${this.sanitizer.sanitize(response.headers)}`);
|
|
return response;
|
|
}
|
|
}
|
|
var getDefaultUserAgentHeaderName = getDefaultUserAgentKey;
|
|
|
|
class UserAgentPolicy extends BaseRequestPolicy {
|
|
constructor(_nextPolicy, _options, headerKey, headerValue) {
|
|
super(_nextPolicy, _options);
|
|
this._nextPolicy = _nextPolicy;
|
|
this._options = _options;
|
|
this.headerKey = headerKey;
|
|
this.headerValue = headerValue;
|
|
}
|
|
sendRequest(request) {
|
|
this.addUserAgentHeader(request);
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
addUserAgentHeader(request) {
|
|
if (!request.headers)
|
|
request.headers = new HttpHeaders;
|
|
if (!request.headers.get(this.headerKey) && this.headerValue)
|
|
request.headers.set(this.headerKey, this.headerValue);
|
|
}
|
|
}
|
|
exports.QueryCollectionFormat = undefined;
|
|
(function(QueryCollectionFormat) {
|
|
QueryCollectionFormat["Csv"] = ",";
|
|
QueryCollectionFormat["Ssv"] = " ";
|
|
QueryCollectionFormat["Tsv"] = "\t";
|
|
QueryCollectionFormat["Pipes"] = "|";
|
|
QueryCollectionFormat["Multi"] = "Multi";
|
|
})(exports.QueryCollectionFormat || (exports.QueryCollectionFormat = {}));
|
|
var DEFAULT_CYCLER_OPTIONS = {
|
|
forcedRefreshWindowInMs: 1000,
|
|
retryIntervalInMs: 3000,
|
|
refreshWindowInMs: 1000 * 60 * 2
|
|
};
|
|
|
|
class DisableResponseDecompressionPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(request) {
|
|
request.decompressResponse = false;
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
|
|
class GenerateClientRequestIdPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, _requestIdHeaderName) {
|
|
super(nextPolicy, options);
|
|
this._requestIdHeaderName = _requestIdHeaderName;
|
|
}
|
|
sendRequest(request) {
|
|
if (!request.headers.contains(this._requestIdHeaderName))
|
|
request.headers.set(this._requestIdHeaderName, request.requestId);
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
var cachedHttpClient;
|
|
|
|
class NdJsonPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(request) {
|
|
if (typeof request.body === "string" && request.body.startsWith("[")) {
|
|
const body = JSON.parse(request.body);
|
|
if (Array.isArray(body))
|
|
request.body = body.map((item) => JSON.stringify(item) + "\n").join("");
|
|
}
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
var globalNoProxyList = [];
|
|
var noProxyListLoaded = false;
|
|
var globalBypassedMap = new Map;
|
|
|
|
class ProxyPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, proxySettings, customNoProxyList) {
|
|
super(nextPolicy, options);
|
|
this.proxySettings = proxySettings;
|
|
this.customNoProxyList = customNoProxyList;
|
|
}
|
|
sendRequest(request) {
|
|
var _a;
|
|
if (!request.proxySettings && !isBypassed(request.url, (_a = this.customNoProxyList) !== null && _a !== undefined ? _a : globalNoProxyList, this.customNoProxyList ? undefined : globalBypassedMap))
|
|
request.proxySettings = this.proxySettings;
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
|
|
class RPRegistrationPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, _retryTimeout = 30) {
|
|
super(nextPolicy, options);
|
|
this._retryTimeout = _retryTimeout;
|
|
}
|
|
sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(request.clone()).then((response) => registerIfNeeded(this, request, response));
|
|
}
|
|
}
|
|
|
|
class SigningPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, authenticationProvider) {
|
|
super(nextPolicy, options);
|
|
this.authenticationProvider = authenticationProvider;
|
|
}
|
|
signRequest(request) {
|
|
return this.authenticationProvider.signRequest(request);
|
|
}
|
|
sendRequest(request) {
|
|
return this.signRequest(request).then((nextRequest) => this._nextPolicy.sendRequest(nextRequest));
|
|
}
|
|
}
|
|
|
|
class SystemErrorRetryPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, retryCount, retryInterval, minRetryInterval, maxRetryInterval) {
|
|
super(nextPolicy, options);
|
|
this.retryCount = isNumber(retryCount) ? retryCount : DEFAULT_CLIENT_RETRY_COUNT;
|
|
this.retryInterval = isNumber(retryInterval) ? retryInterval : DEFAULT_CLIENT_RETRY_INTERVAL;
|
|
this.minRetryInterval = isNumber(minRetryInterval) ? minRetryInterval : DEFAULT_CLIENT_MIN_RETRY_INTERVAL;
|
|
this.maxRetryInterval = isNumber(maxRetryInterval) ? maxRetryInterval : DEFAULT_CLIENT_MAX_RETRY_INTERVAL;
|
|
}
|
|
sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(request.clone()).catch((error) => retry(this, request, error.response, error));
|
|
}
|
|
}
|
|
var DEFAULT_CLIENT_MAX_RETRY_COUNT = 3;
|
|
var StatusCodes = Constants.HttpConstants.StatusCodes;
|
|
var StandardAbortMessage = "The operation was aborted.";
|
|
|
|
class ThrottlingRetryPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, _handleResponse) {
|
|
super(nextPolicy, options);
|
|
this.numberOfRetries = 0;
|
|
this._handleResponse = _handleResponse || this._defaultResponseHandler;
|
|
}
|
|
async sendRequest(httpRequest) {
|
|
const response = await this._nextPolicy.sendRequest(httpRequest.clone());
|
|
if (response.status !== StatusCodes.TooManyRequests && response.status !== StatusCodes.ServiceUnavailable)
|
|
return response;
|
|
else
|
|
return this._handleResponse(httpRequest, response);
|
|
}
|
|
async _defaultResponseHandler(httpRequest, httpResponse) {
|
|
var _a;
|
|
const retryAfterHeader = httpResponse.headers.get(Constants.HeaderConstants.RETRY_AFTER);
|
|
if (retryAfterHeader) {
|
|
const delayInMs = ThrottlingRetryPolicy.parseRetryAfterHeader(retryAfterHeader);
|
|
if (delayInMs) {
|
|
this.numberOfRetries += 1;
|
|
await coreUtil.delay(delayInMs, {
|
|
abortSignal: httpRequest.abortSignal,
|
|
abortErrorMsg: StandardAbortMessage
|
|
});
|
|
if ((_a = httpRequest.abortSignal) === null || _a === undefined ? undefined : _a.aborted)
|
|
throw new abortController.AbortError(StandardAbortMessage);
|
|
if (this.numberOfRetries < DEFAULT_CLIENT_MAX_RETRY_COUNT)
|
|
return this.sendRequest(httpRequest);
|
|
else
|
|
return this._nextPolicy.sendRequest(httpRequest);
|
|
}
|
|
}
|
|
return httpResponse;
|
|
}
|
|
static parseRetryAfterHeader(headerValue) {
|
|
const retryAfterInSeconds = Number(headerValue);
|
|
if (Number.isNaN(retryAfterInSeconds))
|
|
return ThrottlingRetryPolicy.parseDateRetryAfterHeader(headerValue);
|
|
else
|
|
return retryAfterInSeconds * 1000;
|
|
}
|
|
static parseDateRetryAfterHeader(headerValue) {
|
|
try {
|
|
const now = Date.now();
|
|
const date = Date.parse(headerValue);
|
|
const diff = date - now;
|
|
return Number.isNaN(diff) ? undefined : diff;
|
|
} catch (error) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
var createSpan = coreTracing.createSpanFunction({
|
|
packagePrefix: "",
|
|
namespace: ""
|
|
});
|
|
|
|
class TracingPolicy extends BaseRequestPolicy {
|
|
constructor(nextPolicy, options, tracingOptions) {
|
|
super(nextPolicy, options);
|
|
this.userAgent = tracingOptions.userAgent;
|
|
}
|
|
async sendRequest(request) {
|
|
if (!request.tracingContext)
|
|
return this._nextPolicy.sendRequest(request);
|
|
const span = this.tryCreateSpan(request);
|
|
if (!span)
|
|
return this._nextPolicy.sendRequest(request);
|
|
try {
|
|
const response = await this._nextPolicy.sendRequest(request);
|
|
this.tryProcessResponse(span, response);
|
|
return response;
|
|
} catch (err) {
|
|
this.tryProcessError(span, err);
|
|
throw err;
|
|
}
|
|
}
|
|
tryCreateSpan(request) {
|
|
var _a;
|
|
try {
|
|
const { span } = createSpan(`HTTP ${request.method}`, {
|
|
tracingOptions: {
|
|
spanOptions: Object.assign(Object.assign({}, request.spanOptions), { kind: coreTracing.SpanKind.CLIENT }),
|
|
tracingContext: request.tracingContext
|
|
}
|
|
});
|
|
if (!span.isRecording()) {
|
|
span.end();
|
|
return;
|
|
}
|
|
const namespaceFromContext = (_a = request.tracingContext) === null || _a === undefined ? undefined : _a.getValue(Symbol.for("az.namespace"));
|
|
if (typeof namespaceFromContext === "string")
|
|
span.setAttribute("az.namespace", namespaceFromContext);
|
|
span.setAttributes({
|
|
"http.method": request.method,
|
|
"http.url": request.url,
|
|
requestId: request.requestId
|
|
});
|
|
if (this.userAgent)
|
|
span.setAttribute("http.user_agent", this.userAgent);
|
|
const spanContext = span.spanContext();
|
|
const traceParentHeader = coreTracing.getTraceParentHeader(spanContext);
|
|
if (traceParentHeader && coreTracing.isSpanContextValid(spanContext)) {
|
|
request.headers.set("traceparent", traceParentHeader);
|
|
const traceState = spanContext.traceState && spanContext.traceState.serialize();
|
|
if (traceState)
|
|
request.headers.set("tracestate", traceState);
|
|
}
|
|
return span;
|
|
} catch (error) {
|
|
logger.warning(`Skipping creating a tracing span due to an error: ${error.message}`);
|
|
return;
|
|
}
|
|
}
|
|
tryProcessError(span, err) {
|
|
try {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: err.message
|
|
});
|
|
if (err.statusCode)
|
|
span.setAttribute("http.status_code", err.statusCode);
|
|
span.end();
|
|
} catch (error) {
|
|
logger.warning(`Skipping tracing span processing due to an error: ${error.message}`);
|
|
}
|
|
}
|
|
tryProcessResponse(span, response) {
|
|
try {
|
|
span.setAttribute("http.status_code", response.status);
|
|
const serviceRequestId = response.headers.get("x-ms-request-id");
|
|
if (serviceRequestId)
|
|
span.setAttribute("serviceRequestId", serviceRequestId);
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.OK
|
|
});
|
|
span.end();
|
|
} catch (error) {
|
|
logger.warning(`Skipping tracing span processing due to an error: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
class ServiceClient {
|
|
constructor(credentials, options) {
|
|
if (!options)
|
|
options = {};
|
|
this._withCredentials = options.withCredentials || false;
|
|
this._httpClient = options.httpClient || getCachedDefaultHttpClient();
|
|
this._requestPolicyOptions = new RequestPolicyOptions(options.httpPipelineLogger);
|
|
let requestPolicyFactories;
|
|
if (Array.isArray(options.requestPolicyFactories)) {
|
|
logger.info("ServiceClient: using custom request policies");
|
|
requestPolicyFactories = options.requestPolicyFactories;
|
|
} else {
|
|
let authPolicyFactory = undefined;
|
|
if (coreAuth.isTokenCredential(credentials)) {
|
|
logger.info("ServiceClient: creating bearer token authentication policy from provided credentials");
|
|
const wrappedPolicyFactory = () => {
|
|
let bearerTokenPolicyFactory = undefined;
|
|
const serviceClient = this;
|
|
const serviceClientOptions = options;
|
|
return {
|
|
create(nextPolicy, createOptions) {
|
|
const credentialScopes = getCredentialScopes(serviceClientOptions, serviceClient.baseUri);
|
|
if (!credentialScopes)
|
|
throw new Error(`When using credential, the ServiceClient must contain a baseUri or a credentialScopes in ServiceClientOptions. Unable to create a bearerTokenAuthenticationPolicy`);
|
|
if (bearerTokenPolicyFactory === undefined || bearerTokenPolicyFactory === null)
|
|
bearerTokenPolicyFactory = bearerTokenAuthenticationPolicy(credentials, credentialScopes);
|
|
return bearerTokenPolicyFactory.create(nextPolicy, createOptions);
|
|
}
|
|
};
|
|
};
|
|
authPolicyFactory = wrappedPolicyFactory();
|
|
} else if (credentials && typeof credentials.signRequest === "function") {
|
|
logger.info("ServiceClient: creating signing policy from provided credentials");
|
|
authPolicyFactory = signingPolicy(credentials);
|
|
} else if (credentials !== undefined && credentials !== null)
|
|
throw new Error("The credentials argument must implement the TokenCredential interface");
|
|
logger.info("ServiceClient: using default request policies");
|
|
requestPolicyFactories = createDefaultRequestPolicyFactories(authPolicyFactory, options);
|
|
if (options.requestPolicyFactories) {
|
|
const newRequestPolicyFactories = options.requestPolicyFactories(requestPolicyFactories);
|
|
if (newRequestPolicyFactories)
|
|
requestPolicyFactories = newRequestPolicyFactories;
|
|
}
|
|
}
|
|
this._requestPolicyFactories = requestPolicyFactories;
|
|
}
|
|
sendRequest(options) {
|
|
if (options === null || options === undefined || typeof options !== "object")
|
|
throw new Error("options cannot be null or undefined and it must be of type object.");
|
|
let httpRequest;
|
|
try {
|
|
if (isWebResourceLike(options)) {
|
|
options.validateRequestProperties();
|
|
httpRequest = options;
|
|
} else {
|
|
httpRequest = new WebResource;
|
|
httpRequest = httpRequest.prepare(options);
|
|
}
|
|
} catch (error) {
|
|
return Promise.reject(error);
|
|
}
|
|
let httpPipeline = this._httpClient;
|
|
if (this._requestPolicyFactories && this._requestPolicyFactories.length > 0)
|
|
for (let i = this._requestPolicyFactories.length - 1;i >= 0; --i)
|
|
httpPipeline = this._requestPolicyFactories[i].create(httpPipeline, this._requestPolicyOptions);
|
|
return httpPipeline.sendRequest(httpRequest);
|
|
}
|
|
async sendOperationRequest(operationArguments, operationSpec, callback) {
|
|
var _a;
|
|
if (typeof operationArguments.options === "function") {
|
|
callback = operationArguments.options;
|
|
operationArguments.options = undefined;
|
|
}
|
|
const serializerOptions = (_a = operationArguments.options) === null || _a === undefined ? undefined : _a.serializerOptions;
|
|
const httpRequest = new WebResource;
|
|
let result;
|
|
try {
|
|
const baseUri = operationSpec.baseUrl || this.baseUri;
|
|
if (!baseUri)
|
|
throw new Error("If operationSpec.baseUrl is not specified, then the ServiceClient must have a baseUri string property that contains the base URL to use.");
|
|
httpRequest.method = operationSpec.httpMethod;
|
|
httpRequest.operationSpec = operationSpec;
|
|
const requestUrl = URLBuilder.parse(baseUri);
|
|
if (operationSpec.path)
|
|
requestUrl.appendPath(operationSpec.path);
|
|
if (operationSpec.urlParameters && operationSpec.urlParameters.length > 0)
|
|
for (const urlParameter of operationSpec.urlParameters) {
|
|
let urlParameterValue = getOperationArgumentValueFromParameter(this, operationArguments, urlParameter, operationSpec.serializer);
|
|
urlParameterValue = operationSpec.serializer.serialize(urlParameter.mapper, urlParameterValue, getPathStringFromParameter(urlParameter), serializerOptions);
|
|
if (!urlParameter.skipEncoding)
|
|
urlParameterValue = encodeURIComponent(urlParameterValue);
|
|
requestUrl.replaceAll(`{${urlParameter.mapper.serializedName || getPathStringFromParameter(urlParameter)}}`, urlParameterValue);
|
|
}
|
|
if (operationSpec.queryParameters && operationSpec.queryParameters.length > 0)
|
|
for (const queryParameter of operationSpec.queryParameters) {
|
|
let queryParameterValue = getOperationArgumentValueFromParameter(this, operationArguments, queryParameter, operationSpec.serializer);
|
|
if (queryParameterValue !== undefined && queryParameterValue !== null) {
|
|
queryParameterValue = operationSpec.serializer.serialize(queryParameter.mapper, queryParameterValue, getPathStringFromParameter(queryParameter), serializerOptions);
|
|
if (queryParameter.collectionFormat !== undefined && queryParameter.collectionFormat !== null) {
|
|
if (queryParameter.collectionFormat === exports.QueryCollectionFormat.Multi)
|
|
if (queryParameterValue.length === 0)
|
|
continue;
|
|
else
|
|
for (const index in queryParameterValue) {
|
|
const item = queryParameterValue[index];
|
|
queryParameterValue[index] = item === undefined || item === null ? "" : item.toString();
|
|
}
|
|
else if (queryParameter.collectionFormat === exports.QueryCollectionFormat.Ssv || queryParameter.collectionFormat === exports.QueryCollectionFormat.Tsv)
|
|
queryParameterValue = queryParameterValue.join(queryParameter.collectionFormat);
|
|
}
|
|
if (!queryParameter.skipEncoding)
|
|
if (Array.isArray(queryParameterValue)) {
|
|
for (const index in queryParameterValue)
|
|
if (queryParameterValue[index] !== undefined && queryParameterValue[index] !== null)
|
|
queryParameterValue[index] = encodeURIComponent(queryParameterValue[index]);
|
|
} else
|
|
queryParameterValue = encodeURIComponent(queryParameterValue);
|
|
if (queryParameter.collectionFormat !== undefined && queryParameter.collectionFormat !== null && queryParameter.collectionFormat !== exports.QueryCollectionFormat.Multi && queryParameter.collectionFormat !== exports.QueryCollectionFormat.Ssv && queryParameter.collectionFormat !== exports.QueryCollectionFormat.Tsv)
|
|
queryParameterValue = queryParameterValue.join(queryParameter.collectionFormat);
|
|
requestUrl.setQueryParameter(queryParameter.mapper.serializedName || getPathStringFromParameter(queryParameter), queryParameterValue);
|
|
}
|
|
}
|
|
httpRequest.url = requestUrl.toString();
|
|
const contentType = operationSpec.contentType || this.requestContentType;
|
|
if (contentType && operationSpec.requestBody)
|
|
httpRequest.headers.set("Content-Type", contentType);
|
|
if (operationSpec.headerParameters)
|
|
for (const headerParameter of operationSpec.headerParameters) {
|
|
let headerValue = getOperationArgumentValueFromParameter(this, operationArguments, headerParameter, operationSpec.serializer);
|
|
if (headerValue !== undefined && headerValue !== null) {
|
|
headerValue = operationSpec.serializer.serialize(headerParameter.mapper, headerValue, getPathStringFromParameter(headerParameter), serializerOptions);
|
|
const headerCollectionPrefix = headerParameter.mapper.headerCollectionPrefix;
|
|
if (headerCollectionPrefix)
|
|
for (const key of Object.keys(headerValue))
|
|
httpRequest.headers.set(headerCollectionPrefix + key, headerValue[key]);
|
|
else
|
|
httpRequest.headers.set(headerParameter.mapper.serializedName || getPathStringFromParameter(headerParameter), headerValue);
|
|
}
|
|
}
|
|
const options = operationArguments.options;
|
|
if (options) {
|
|
if (options.customHeaders)
|
|
for (const customHeaderName in options.customHeaders)
|
|
httpRequest.headers.set(customHeaderName, options.customHeaders[customHeaderName]);
|
|
if (options.abortSignal)
|
|
httpRequest.abortSignal = options.abortSignal;
|
|
if (options.timeout)
|
|
httpRequest.timeout = options.timeout;
|
|
if (options.onUploadProgress)
|
|
httpRequest.onUploadProgress = options.onUploadProgress;
|
|
if (options.onDownloadProgress)
|
|
httpRequest.onDownloadProgress = options.onDownloadProgress;
|
|
if (options.spanOptions)
|
|
httpRequest.spanOptions = options.spanOptions;
|
|
if (options.tracingContext)
|
|
httpRequest.tracingContext = options.tracingContext;
|
|
if (options.shouldDeserialize !== undefined && options.shouldDeserialize !== null)
|
|
httpRequest.shouldDeserialize = options.shouldDeserialize;
|
|
}
|
|
httpRequest.withCredentials = this._withCredentials;
|
|
serializeRequestBody(this, httpRequest, operationArguments, operationSpec);
|
|
if (httpRequest.streamResponseStatusCodes === undefined)
|
|
httpRequest.streamResponseStatusCodes = getStreamResponseStatusCodes(operationSpec);
|
|
let rawResponse;
|
|
let sendRequestError;
|
|
try {
|
|
rawResponse = await this.sendRequest(httpRequest);
|
|
} catch (error) {
|
|
sendRequestError = error;
|
|
}
|
|
if (sendRequestError) {
|
|
if (sendRequestError.response)
|
|
sendRequestError.details = flattenResponse(sendRequestError.response, operationSpec.responses[sendRequestError.statusCode] || operationSpec.responses["default"]);
|
|
result = Promise.reject(sendRequestError);
|
|
} else
|
|
result = Promise.resolve(flattenResponse(rawResponse, operationSpec.responses[rawResponse.status]));
|
|
} catch (error) {
|
|
result = Promise.reject(error);
|
|
}
|
|
const cb = callback;
|
|
if (cb)
|
|
result.then((res) => cb(null, res._response.parsedBody, res._response.request, res._response)).catch((err) => cb(err));
|
|
return result;
|
|
}
|
|
}
|
|
var TokenRefreshBufferMs = 2 * 60 * 1000;
|
|
|
|
class ExpiringAccessTokenCache {
|
|
constructor(tokenRefreshBufferMs = TokenRefreshBufferMs) {
|
|
this.cachedToken = undefined;
|
|
this.tokenRefreshBufferMs = tokenRefreshBufferMs;
|
|
}
|
|
setCachedToken(accessToken) {
|
|
this.cachedToken = accessToken;
|
|
}
|
|
getCachedToken() {
|
|
if (this.cachedToken && Date.now() + this.tokenRefreshBufferMs >= this.cachedToken.expiresOnTimestamp)
|
|
this.cachedToken = undefined;
|
|
return this.cachedToken;
|
|
}
|
|
}
|
|
|
|
class AccessTokenRefresher {
|
|
constructor(credential, scopes, requiredMillisecondsBeforeNewRefresh = 30000) {
|
|
this.credential = credential;
|
|
this.scopes = scopes;
|
|
this.requiredMillisecondsBeforeNewRefresh = requiredMillisecondsBeforeNewRefresh;
|
|
this.lastCalled = 0;
|
|
}
|
|
isReady() {
|
|
return !this.lastCalled || Date.now() - this.lastCalled > this.requiredMillisecondsBeforeNewRefresh;
|
|
}
|
|
async getToken(options) {
|
|
this.lastCalled = Date.now();
|
|
const token = await this.credential.getToken(this.scopes, options);
|
|
this.promise = undefined;
|
|
return token || undefined;
|
|
}
|
|
refresh(options) {
|
|
if (!this.promise)
|
|
this.promise = this.getToken(options);
|
|
return this.promise;
|
|
}
|
|
}
|
|
var HeaderConstants = Constants.HeaderConstants;
|
|
var DEFAULT_AUTHORIZATION_SCHEME = "Basic";
|
|
|
|
class BasicAuthenticationCredentials {
|
|
constructor(userName, password, authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME) {
|
|
this.authorizationScheme = DEFAULT_AUTHORIZATION_SCHEME;
|
|
if (userName === null || userName === undefined || typeof userName.valueOf() !== "string")
|
|
throw new Error("userName cannot be null or undefined and must be of type string.");
|
|
if (password === null || password === undefined || typeof password.valueOf() !== "string")
|
|
throw new Error("password cannot be null or undefined and must be of type string.");
|
|
this.userName = userName;
|
|
this.password = password;
|
|
this.authorizationScheme = authorizationScheme;
|
|
}
|
|
signRequest(webResource) {
|
|
const credentials = `${this.userName}:${this.password}`;
|
|
const encodedCredentials = `${this.authorizationScheme} ${encodeString(credentials)}`;
|
|
if (!webResource.headers)
|
|
webResource.headers = new HttpHeaders;
|
|
webResource.headers.set(HeaderConstants.AUTHORIZATION, encodedCredentials);
|
|
return Promise.resolve(webResource);
|
|
}
|
|
}
|
|
|
|
class ApiKeyCredentials {
|
|
constructor(options) {
|
|
if (!options || options && !options.inHeader && !options.inQuery)
|
|
throw new Error(`options cannot be null or undefined. Either "inHeader" or "inQuery" property of the options object needs to be provided.`);
|
|
this.inHeader = options.inHeader;
|
|
this.inQuery = options.inQuery;
|
|
}
|
|
signRequest(webResource) {
|
|
if (!webResource)
|
|
return Promise.reject(new Error(`webResource cannot be null or undefined and must be of type "object".`));
|
|
if (this.inHeader) {
|
|
if (!webResource.headers)
|
|
webResource.headers = new HttpHeaders;
|
|
for (const headerName in this.inHeader)
|
|
webResource.headers.set(headerName, this.inHeader[headerName]);
|
|
}
|
|
if (this.inQuery) {
|
|
if (!webResource.url)
|
|
return Promise.reject(new Error(`url cannot be null in the request object.`));
|
|
if (webResource.url.indexOf("?") < 0)
|
|
webResource.url += "?";
|
|
for (const key in this.inQuery) {
|
|
if (!webResource.url.endsWith("?"))
|
|
webResource.url += "&";
|
|
webResource.url += `${key}=${this.inQuery[key]}`;
|
|
}
|
|
}
|
|
return Promise.resolve(webResource);
|
|
}
|
|
}
|
|
|
|
class TopicCredentials extends ApiKeyCredentials {
|
|
constructor(topicKey) {
|
|
if (!topicKey || topicKey && typeof topicKey !== "string")
|
|
throw new Error("topicKey cannot be null or undefined and must be of type string.");
|
|
const options = {
|
|
inHeader: {
|
|
"aeg-sas-key": topicKey
|
|
}
|
|
};
|
|
super(options);
|
|
}
|
|
}
|
|
Object.defineProperty(exports, "delay", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreUtil.delay;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "isTokenCredential", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreAuth.isTokenCredential;
|
|
}
|
|
});
|
|
exports.AccessTokenRefresher = AccessTokenRefresher;
|
|
exports.ApiKeyCredentials = ApiKeyCredentials;
|
|
exports.BaseRequestPolicy = BaseRequestPolicy;
|
|
exports.BasicAuthenticationCredentials = BasicAuthenticationCredentials;
|
|
exports.Constants = Constants;
|
|
exports.DefaultHttpClient = NodeFetchHttpClient;
|
|
exports.ExpiringAccessTokenCache = ExpiringAccessTokenCache;
|
|
exports.HttpHeaders = HttpHeaders;
|
|
exports.MapperType = MapperType;
|
|
exports.RequestPolicyOptions = RequestPolicyOptions;
|
|
exports.RestError = RestError;
|
|
exports.Serializer = Serializer;
|
|
exports.ServiceClient = ServiceClient;
|
|
exports.TopicCredentials = TopicCredentials;
|
|
exports.URLBuilder = URLBuilder;
|
|
exports.URLQuery = URLQuery;
|
|
exports.WebResource = WebResource;
|
|
exports.XML_ATTRKEY = XML_ATTRKEY;
|
|
exports.XML_CHARKEY = XML_CHARKEY;
|
|
exports.applyMixins = applyMixins;
|
|
exports.bearerTokenAuthenticationPolicy = bearerTokenAuthenticationPolicy;
|
|
exports.createPipelineFromOptions = createPipelineFromOptions;
|
|
exports.createSpanFunction = createSpanFunction;
|
|
exports.deserializationPolicy = deserializationPolicy;
|
|
exports.deserializeResponseBody = deserializeResponseBody;
|
|
exports.disableResponseDecompressionPolicy = disableResponseDecompressionPolicy;
|
|
exports.encodeUri = encodeUri;
|
|
exports.executePromisesSequentially = executePromisesSequentially;
|
|
exports.exponentialRetryPolicy = exponentialRetryPolicy;
|
|
exports.flattenResponse = flattenResponse;
|
|
exports.generateClientRequestIdPolicy = generateClientRequestIdPolicy;
|
|
exports.generateUuid = generateUuid;
|
|
exports.getDefaultProxySettings = getDefaultProxySettings;
|
|
exports.getDefaultUserAgentValue = getDefaultUserAgentValue;
|
|
exports.isDuration = isDuration;
|
|
exports.isNode = isNode;
|
|
exports.isValidUuid = isValidUuid;
|
|
exports.keepAlivePolicy = keepAlivePolicy;
|
|
exports.logPolicy = logPolicy;
|
|
exports.operationOptionsToRequestOptionsBase = operationOptionsToRequestOptionsBase;
|
|
exports.parseXML = parseXML;
|
|
exports.promiseToCallback = promiseToCallback;
|
|
exports.promiseToServiceCallback = promiseToServiceCallback;
|
|
exports.proxyPolicy = proxyPolicy;
|
|
exports.redirectPolicy = redirectPolicy;
|
|
exports.serializeObject = serializeObject;
|
|
exports.signingPolicy = signingPolicy;
|
|
exports.stringifyXML = stringifyXML;
|
|
exports.stripRequest = stripRequest;
|
|
exports.stripResponse = stripResponse;
|
|
exports.systemErrorRetryPolicy = systemErrorRetryPolicy;
|
|
exports.throttlingRetryPolicy = throttlingRetryPolicy;
|
|
exports.tracingPolicy = tracingPolicy;
|
|
exports.userAgentPolicy = userAgentPolicy;
|
|
});
|
|
|
|
// node_modules/@azure/core-paging/dist/index.js
|
|
var require_dist7 = __commonJS((exports) => {
|
|
var getPagedAsyncIterator = function(pagedResult) {
|
|
var _a;
|
|
const iter = getItemAsyncIterator(pagedResult);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (_a = pagedResult === null || pagedResult === undefined ? undefined : pagedResult.byPage) !== null && _a !== undefined ? _a : (settings) => {
|
|
const { continuationToken, maxPageSize } = settings !== null && settings !== undefined ? settings : {};
|
|
return getPageAsyncIterator(pagedResult, {
|
|
pageLink: continuationToken,
|
|
maxPageSize
|
|
});
|
|
}
|
|
};
|
|
};
|
|
var getItemAsyncIterator = function(pagedResult) {
|
|
return tslib.__asyncGenerator(this, arguments, function* getItemAsyncIterator_1() {
|
|
var e_1, _a, e_2, _b;
|
|
const pages = getPageAsyncIterator(pagedResult);
|
|
const firstVal = yield tslib.__await(pages.next());
|
|
if (!Array.isArray(firstVal.value)) {
|
|
const { toElements } = pagedResult;
|
|
if (toElements) {
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(toElements(firstVal.value))));
|
|
try {
|
|
for (var pages_1 = tslib.__asyncValues(pages), pages_1_1;pages_1_1 = yield tslib.__await(pages_1.next()), !pages_1_1.done; ) {
|
|
const page = pages_1_1.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(toElements(page))));
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (pages_1_1 && !pages_1_1.done && (_a = pages_1.return))
|
|
yield tslib.__await(_a.call(pages_1));
|
|
} finally {
|
|
if (e_1)
|
|
throw e_1.error;
|
|
}
|
|
}
|
|
} else {
|
|
yield yield tslib.__await(firstVal.value);
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(pages)));
|
|
}
|
|
} else {
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(firstVal.value)));
|
|
try {
|
|
for (var pages_2 = tslib.__asyncValues(pages), pages_2_1;pages_2_1 = yield tslib.__await(pages_2.next()), !pages_2_1.done; ) {
|
|
const page = pages_2_1.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(page)));
|
|
}
|
|
} catch (e_2_1) {
|
|
e_2 = { error: e_2_1 };
|
|
} finally {
|
|
try {
|
|
if (pages_2_1 && !pages_2_1.done && (_b = pages_2.return))
|
|
yield tslib.__await(_b.call(pages_2));
|
|
} finally {
|
|
if (e_2)
|
|
throw e_2.error;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var getPageAsyncIterator = function(pagedResult, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* getPageAsyncIterator_1() {
|
|
const { pageLink, maxPageSize } = options;
|
|
let response = yield tslib.__await(pagedResult.getPage(pageLink !== null && pageLink !== undefined ? pageLink : pagedResult.firstPageLink, maxPageSize));
|
|
if (!response)
|
|
return yield tslib.__await(undefined);
|
|
yield yield tslib.__await(response.page);
|
|
while (response.nextPageLink) {
|
|
response = yield tslib.__await(pagedResult.getPage(response.nextPageLink, maxPageSize));
|
|
if (!response)
|
|
return yield tslib.__await(undefined);
|
|
yield yield tslib.__await(response.page);
|
|
}
|
|
});
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib = (init_tslib_es6(), __toCommonJS(exports_tslib_es6));
|
|
exports.getPagedAsyncIterator = getPagedAsyncIterator;
|
|
});
|
|
|
|
// node_modules/@azure/core-lro/dist/index.js
|
|
var require_dist8 = __commonJS((exports) => {
|
|
var deserializeState = function(serializedState) {
|
|
try {
|
|
return JSON.parse(serializedState).state;
|
|
} catch (e) {
|
|
throw new Error(`Unable to deserialize input state: ${serializedState}`);
|
|
}
|
|
};
|
|
var setStateError = function(inputs) {
|
|
const { state, stateProxy, isOperationError: isOperationError2 } = inputs;
|
|
return (error) => {
|
|
if (isOperationError2(error)) {
|
|
stateProxy.setError(state, error);
|
|
stateProxy.setFailed(state);
|
|
}
|
|
throw error;
|
|
};
|
|
};
|
|
var processOperationStatus = function(result) {
|
|
const { state, stateProxy, status, isDone, processResult, response, setErrorAsResult } = result;
|
|
switch (status) {
|
|
case "succeeded": {
|
|
stateProxy.setSucceeded(state);
|
|
break;
|
|
}
|
|
case "failed": {
|
|
stateProxy.setError(state, new Error(`The long-running operation has failed`));
|
|
stateProxy.setFailed(state);
|
|
break;
|
|
}
|
|
case "canceled": {
|
|
stateProxy.setCanceled(state);
|
|
break;
|
|
}
|
|
}
|
|
if ((isDone === null || isDone === undefined ? undefined : isDone(response, state)) || isDone === undefined && ["succeeded", "canceled"].concat(setErrorAsResult ? [] : ["failed"]).includes(status))
|
|
stateProxy.setResult(state, buildResult({
|
|
response,
|
|
state,
|
|
processResult
|
|
}));
|
|
};
|
|
var buildResult = function(inputs) {
|
|
const { processResult, response, state } = inputs;
|
|
return processResult ? processResult(response, state) : response;
|
|
};
|
|
async function initOperation(inputs) {
|
|
const { init, stateProxy, processResult, getOperationStatus: getOperationStatus2, withOperationLocation, setErrorAsResult } = inputs;
|
|
const { operationLocation, resourceLocation, metadata, response } = await init();
|
|
if (operationLocation)
|
|
withOperationLocation === null || withOperationLocation === undefined || withOperationLocation(operationLocation, false);
|
|
const config = {
|
|
metadata,
|
|
operationLocation,
|
|
resourceLocation
|
|
};
|
|
logger.verbose(`LRO: Operation description:`, config);
|
|
const state = stateProxy.initState(config);
|
|
const status = getOperationStatus2({ response, state, operationLocation });
|
|
processOperationStatus({ state, status, stateProxy, response, setErrorAsResult, processResult });
|
|
return state;
|
|
}
|
|
async function pollOperationHelper(inputs) {
|
|
const { poll, state, stateProxy, operationLocation, getOperationStatus: getOperationStatus2, getResourceLocation: getResourceLocation2, isOperationError: isOperationError2, options } = inputs;
|
|
const response = await poll(operationLocation, options).catch(setStateError({
|
|
state,
|
|
stateProxy,
|
|
isOperationError: isOperationError2
|
|
}));
|
|
const status = getOperationStatus2(response, state);
|
|
logger.verbose(`LRO: Status:\n\tPolling from: ${state.config.operationLocation}\n\tOperation status: ${status}\n\tPolling status: ${terminalStates.includes(status) ? "Stopped" : "Running"}`);
|
|
if (status === "succeeded") {
|
|
const resourceLocation = getResourceLocation2(response, state);
|
|
if (resourceLocation !== undefined)
|
|
return {
|
|
response: await poll(resourceLocation).catch(setStateError({ state, stateProxy, isOperationError: isOperationError2 })),
|
|
status
|
|
};
|
|
}
|
|
return { response, status };
|
|
}
|
|
async function pollOperation(inputs) {
|
|
const { poll, state, stateProxy, options, getOperationStatus: getOperationStatus2, getResourceLocation: getResourceLocation2, getOperationLocation: getOperationLocation2, isOperationError: isOperationError2, withOperationLocation, getPollingInterval, processResult, updateState, setDelay, isDone, setErrorAsResult } = inputs;
|
|
const { operationLocation } = state.config;
|
|
if (operationLocation !== undefined) {
|
|
const { response, status } = await pollOperationHelper({
|
|
poll,
|
|
getOperationStatus: getOperationStatus2,
|
|
state,
|
|
stateProxy,
|
|
operationLocation,
|
|
getResourceLocation: getResourceLocation2,
|
|
isOperationError: isOperationError2,
|
|
options
|
|
});
|
|
processOperationStatus({
|
|
status,
|
|
response,
|
|
state,
|
|
stateProxy,
|
|
isDone,
|
|
processResult,
|
|
setErrorAsResult
|
|
});
|
|
if (!terminalStates.includes(status)) {
|
|
const intervalInMs = getPollingInterval === null || getPollingInterval === undefined ? undefined : getPollingInterval(response);
|
|
if (intervalInMs)
|
|
setDelay(intervalInMs);
|
|
const location = getOperationLocation2 === null || getOperationLocation2 === undefined ? undefined : getOperationLocation2(response, state);
|
|
if (location !== undefined) {
|
|
const isUpdated = operationLocation !== location;
|
|
state.config.operationLocation = location;
|
|
withOperationLocation === null || withOperationLocation === undefined || withOperationLocation(location, isUpdated);
|
|
} else
|
|
withOperationLocation === null || withOperationLocation === undefined || withOperationLocation(operationLocation, false);
|
|
}
|
|
updateState === null || updateState === undefined || updateState(state, response);
|
|
}
|
|
}
|
|
var getOperationLocationPollingUrl = function(inputs) {
|
|
const { azureAsyncOperation, operationLocation } = inputs;
|
|
return operationLocation !== null && operationLocation !== undefined ? operationLocation : azureAsyncOperation;
|
|
};
|
|
var getLocationHeader = function(rawResponse) {
|
|
return rawResponse.headers["location"];
|
|
};
|
|
var getOperationLocationHeader = function(rawResponse) {
|
|
return rawResponse.headers["operation-location"];
|
|
};
|
|
var getAzureAsyncOperationHeader = function(rawResponse) {
|
|
return rawResponse.headers["azure-asyncoperation"];
|
|
};
|
|
var findResourceLocation = function(inputs) {
|
|
const { location, requestMethod, requestPath, resourceLocationConfig } = inputs;
|
|
switch (requestMethod) {
|
|
case "PUT":
|
|
return requestPath;
|
|
case "DELETE":
|
|
return;
|
|
default:
|
|
switch (resourceLocationConfig) {
|
|
case "azure-async-operation":
|
|
return;
|
|
case "original-uri":
|
|
return requestPath;
|
|
case "location":
|
|
default:
|
|
return location;
|
|
}
|
|
}
|
|
};
|
|
var inferLroMode = function(inputs) {
|
|
const { rawResponse, requestMethod, requestPath, resourceLocationConfig } = inputs;
|
|
const operationLocation = getOperationLocationHeader(rawResponse);
|
|
const azureAsyncOperation = getAzureAsyncOperationHeader(rawResponse);
|
|
const pollingUrl = getOperationLocationPollingUrl({ operationLocation, azureAsyncOperation });
|
|
const location = getLocationHeader(rawResponse);
|
|
const normalizedRequestMethod = requestMethod === null || requestMethod === undefined ? undefined : requestMethod.toLocaleUpperCase();
|
|
if (pollingUrl !== undefined)
|
|
return {
|
|
mode: "OperationLocation",
|
|
operationLocation: pollingUrl,
|
|
resourceLocation: findResourceLocation({
|
|
requestMethod: normalizedRequestMethod,
|
|
location,
|
|
requestPath,
|
|
resourceLocationConfig
|
|
})
|
|
};
|
|
else if (location !== undefined)
|
|
return {
|
|
mode: "ResourceLocation",
|
|
operationLocation: location
|
|
};
|
|
else if (normalizedRequestMethod === "PUT" && requestPath)
|
|
return {
|
|
mode: "Body",
|
|
operationLocation: requestPath
|
|
};
|
|
else
|
|
return;
|
|
};
|
|
var transformStatus = function(inputs) {
|
|
const { status, statusCode } = inputs;
|
|
if (typeof status !== "string" && status !== undefined)
|
|
throw new Error(`Polling was unsuccessful. Expected status to have a string value or no value but it has instead: ${status}. This doesn't necessarily indicate the operation has failed. Check your Azure subscription or resource status for more information.`);
|
|
switch (status === null || status === undefined ? undefined : status.toLocaleLowerCase()) {
|
|
case undefined:
|
|
return toOperationStatus(statusCode);
|
|
case "succeeded":
|
|
return "succeeded";
|
|
case "failed":
|
|
return "failed";
|
|
case "running":
|
|
case "accepted":
|
|
case "started":
|
|
case "canceling":
|
|
case "cancelling":
|
|
return "running";
|
|
case "canceled":
|
|
case "cancelled":
|
|
return "canceled";
|
|
default: {
|
|
logger.verbose(`LRO: unrecognized operation status: ${status}`);
|
|
return status;
|
|
}
|
|
}
|
|
};
|
|
var getStatus = function(rawResponse) {
|
|
var _a;
|
|
const { status } = (_a = rawResponse.body) !== null && _a !== undefined ? _a : {};
|
|
return transformStatus({ status, statusCode: rawResponse.statusCode });
|
|
};
|
|
var getProvisioningState = function(rawResponse) {
|
|
var _a, _b;
|
|
const { properties, provisioningState } = (_a = rawResponse.body) !== null && _a !== undefined ? _a : {};
|
|
const status = (_b = properties === null || properties === undefined ? undefined : properties.provisioningState) !== null && _b !== undefined ? _b : provisioningState;
|
|
return transformStatus({ status, statusCode: rawResponse.statusCode });
|
|
};
|
|
var toOperationStatus = function(statusCode) {
|
|
if (statusCode === 202)
|
|
return "running";
|
|
else if (statusCode < 300)
|
|
return "succeeded";
|
|
else
|
|
return "failed";
|
|
};
|
|
var parseRetryAfter = function({ rawResponse }) {
|
|
const retryAfter = rawResponse.headers["retry-after"];
|
|
if (retryAfter !== undefined) {
|
|
const retryAfterInSeconds = parseInt(retryAfter);
|
|
return isNaN(retryAfterInSeconds) ? calculatePollingIntervalFromDate(new Date(retryAfter)) : retryAfterInSeconds * 1000;
|
|
}
|
|
return;
|
|
};
|
|
var calculatePollingIntervalFromDate = function(retryAfterDate) {
|
|
const timeNow = Math.floor(new Date().getTime());
|
|
const retryAfterTime = retryAfterDate.getTime();
|
|
if (timeNow < retryAfterTime)
|
|
return retryAfterTime - timeNow;
|
|
return;
|
|
};
|
|
var getStatusFromInitialResponse = function(inputs) {
|
|
const { response, state, operationLocation } = inputs;
|
|
function helper() {
|
|
var _a;
|
|
const mode = (_a = state.config.metadata) === null || _a === undefined ? undefined : _a["mode"];
|
|
switch (mode) {
|
|
case undefined:
|
|
return toOperationStatus(response.rawResponse.statusCode);
|
|
case "Body":
|
|
return getOperationStatus(response, state);
|
|
default:
|
|
return "running";
|
|
}
|
|
}
|
|
const status = helper();
|
|
return status === "running" && operationLocation === undefined ? "succeeded" : status;
|
|
};
|
|
async function initHttpOperation(inputs) {
|
|
const { stateProxy, resourceLocationConfig, processResult, lro, setErrorAsResult } = inputs;
|
|
return initOperation({
|
|
init: async () => {
|
|
const response = await lro.sendInitialRequest();
|
|
const config = inferLroMode({
|
|
rawResponse: response.rawResponse,
|
|
requestPath: lro.requestPath,
|
|
requestMethod: lro.requestMethod,
|
|
resourceLocationConfig
|
|
});
|
|
return Object.assign({ response, operationLocation: config === null || config === undefined ? undefined : config.operationLocation, resourceLocation: config === null || config === undefined ? undefined : config.resourceLocation }, (config === null || config === undefined ? undefined : config.mode) ? { metadata: { mode: config.mode } } : {});
|
|
},
|
|
stateProxy,
|
|
processResult: processResult ? ({ flatResponse }, state) => processResult(flatResponse, state) : ({ flatResponse }) => flatResponse,
|
|
getOperationStatus: getStatusFromInitialResponse,
|
|
setErrorAsResult
|
|
});
|
|
}
|
|
var getOperationLocation = function({ rawResponse }, state) {
|
|
var _a;
|
|
const mode = (_a = state.config.metadata) === null || _a === undefined ? undefined : _a["mode"];
|
|
switch (mode) {
|
|
case "OperationLocation":
|
|
return getOperationLocationPollingUrl({
|
|
operationLocation: getOperationLocationHeader(rawResponse),
|
|
azureAsyncOperation: getAzureAsyncOperationHeader(rawResponse)
|
|
});
|
|
case "ResourceLocation":
|
|
return getLocationHeader(rawResponse);
|
|
case "Body":
|
|
default:
|
|
return;
|
|
}
|
|
};
|
|
var getOperationStatus = function({ rawResponse }, state) {
|
|
var _a;
|
|
const mode = (_a = state.config.metadata) === null || _a === undefined ? undefined : _a["mode"];
|
|
switch (mode) {
|
|
case "OperationLocation":
|
|
return getStatus(rawResponse);
|
|
case "ResourceLocation":
|
|
return toOperationStatus(rawResponse.statusCode);
|
|
case "Body":
|
|
return getProvisioningState(rawResponse);
|
|
default:
|
|
throw new Error(`Internal error: Unexpected operation mode: ${mode}`);
|
|
}
|
|
};
|
|
var getResourceLocation = function({ flatResponse }, state) {
|
|
if (typeof flatResponse === "object") {
|
|
const resourceLocation = flatResponse.resourceLocation;
|
|
if (resourceLocation !== undefined)
|
|
state.config.resourceLocation = resourceLocation;
|
|
}
|
|
return state.config.resourceLocation;
|
|
};
|
|
var isOperationError = function(e) {
|
|
return e.name === "RestError";
|
|
};
|
|
async function pollHttpOperation(inputs) {
|
|
const { lro, stateProxy, options, processResult, updateState, setDelay, state, setErrorAsResult } = inputs;
|
|
return pollOperation({
|
|
state,
|
|
stateProxy,
|
|
setDelay,
|
|
processResult: processResult ? ({ flatResponse }, inputState) => processResult(flatResponse, inputState) : ({ flatResponse }) => flatResponse,
|
|
updateState,
|
|
getPollingInterval: parseRetryAfter,
|
|
getOperationLocation,
|
|
getOperationStatus,
|
|
isOperationError,
|
|
getResourceLocation,
|
|
options,
|
|
poll: async (location, inputOptions) => lro.sendPollRequest(location, inputOptions),
|
|
setErrorAsResult
|
|
});
|
|
}
|
|
var buildCreatePoller = function(inputs) {
|
|
const { getOperationLocation: getOperationLocation2, getStatusFromInitialResponse: getStatusFromInitialResponse2, getStatusFromPollResponse, isOperationError: isOperationError2, getResourceLocation: getResourceLocation2, getPollingInterval, resolveOnUnsuccessful } = inputs;
|
|
return async ({ init, poll }, options) => {
|
|
const { processResult, updateState, withOperationLocation: withOperationLocationCallback, intervalInMs = POLL_INTERVAL_IN_MS, restoreFrom } = options || {};
|
|
const stateProxy = createStateProxy$1();
|
|
const withOperationLocation = withOperationLocationCallback ? (() => {
|
|
let called = false;
|
|
return (operationLocation, isUpdated) => {
|
|
if (isUpdated)
|
|
withOperationLocationCallback(operationLocation);
|
|
else if (!called)
|
|
withOperationLocationCallback(operationLocation);
|
|
called = true;
|
|
};
|
|
})() : undefined;
|
|
const state = restoreFrom ? deserializeState(restoreFrom) : await initOperation({
|
|
init,
|
|
stateProxy,
|
|
processResult,
|
|
getOperationStatus: getStatusFromInitialResponse2,
|
|
withOperationLocation,
|
|
setErrorAsResult: !resolveOnUnsuccessful
|
|
});
|
|
let resultPromise;
|
|
const abortController$1 = new abortController.AbortController;
|
|
const handlers = new Map;
|
|
const handleProgressEvents = async () => handlers.forEach((h) => h(state));
|
|
const cancelErrMsg = "Operation was canceled";
|
|
let currentPollIntervalInMs = intervalInMs;
|
|
const poller = {
|
|
getOperationState: () => state,
|
|
getResult: () => state.result,
|
|
isDone: () => ["succeeded", "failed", "canceled"].includes(state.status),
|
|
isStopped: () => resultPromise === undefined,
|
|
stopPolling: () => {
|
|
abortController$1.abort();
|
|
},
|
|
toString: () => JSON.stringify({
|
|
state
|
|
}),
|
|
onProgress: (callback) => {
|
|
const s = Symbol();
|
|
handlers.set(s, callback);
|
|
return () => handlers.delete(s);
|
|
},
|
|
pollUntilDone: (pollOptions) => resultPromise !== null && resultPromise !== undefined ? resultPromise : resultPromise = (async () => {
|
|
const { abortSignal: inputAbortSignal } = pollOptions || {};
|
|
const { signal: abortSignal } = inputAbortSignal ? new abortController.AbortController([inputAbortSignal, abortController$1.signal]) : abortController$1;
|
|
if (!poller.isDone()) {
|
|
await poller.poll({ abortSignal });
|
|
while (!poller.isDone()) {
|
|
await coreUtil.delay(currentPollIntervalInMs, { abortSignal });
|
|
await poller.poll({ abortSignal });
|
|
}
|
|
}
|
|
if (resolveOnUnsuccessful)
|
|
return poller.getResult();
|
|
else
|
|
switch (state.status) {
|
|
case "succeeded":
|
|
return poller.getResult();
|
|
case "canceled":
|
|
throw new Error(cancelErrMsg);
|
|
case "failed":
|
|
throw state.error;
|
|
case "notStarted":
|
|
case "running":
|
|
throw new Error(`Polling completed without succeeding or failing`);
|
|
}
|
|
})().finally(() => {
|
|
resultPromise = undefined;
|
|
}),
|
|
async poll(pollOptions) {
|
|
if (resolveOnUnsuccessful) {
|
|
if (poller.isDone())
|
|
return;
|
|
} else
|
|
switch (state.status) {
|
|
case "succeeded":
|
|
return;
|
|
case "canceled":
|
|
throw new Error(cancelErrMsg);
|
|
case "failed":
|
|
throw state.error;
|
|
}
|
|
await pollOperation({
|
|
poll,
|
|
state,
|
|
stateProxy,
|
|
getOperationLocation: getOperationLocation2,
|
|
isOperationError: isOperationError2,
|
|
withOperationLocation,
|
|
getPollingInterval,
|
|
getOperationStatus: getStatusFromPollResponse,
|
|
getResourceLocation: getResourceLocation2,
|
|
processResult,
|
|
updateState,
|
|
options: pollOptions,
|
|
setDelay: (pollIntervalInMs) => {
|
|
currentPollIntervalInMs = pollIntervalInMs;
|
|
},
|
|
setErrorAsResult: !resolveOnUnsuccessful
|
|
});
|
|
await handleProgressEvents();
|
|
if (!resolveOnUnsuccessful)
|
|
switch (state.status) {
|
|
case "canceled":
|
|
throw new Error(cancelErrMsg);
|
|
case "failed":
|
|
throw state.error;
|
|
}
|
|
}
|
|
};
|
|
return poller;
|
|
};
|
|
};
|
|
async function createHttpPoller(lro, options) {
|
|
const { resourceLocationConfig, intervalInMs, processResult, restoreFrom, updateState, withOperationLocation, resolveOnUnsuccessful = false } = options || {};
|
|
return buildCreatePoller({
|
|
getStatusFromInitialResponse,
|
|
getStatusFromPollResponse: getOperationStatus,
|
|
isOperationError,
|
|
getOperationLocation,
|
|
getResourceLocation,
|
|
getPollingInterval: parseRetryAfter,
|
|
resolveOnUnsuccessful
|
|
})({
|
|
init: async () => {
|
|
const response = await lro.sendInitialRequest();
|
|
const config = inferLroMode({
|
|
rawResponse: response.rawResponse,
|
|
requestPath: lro.requestPath,
|
|
requestMethod: lro.requestMethod,
|
|
resourceLocationConfig
|
|
});
|
|
return Object.assign({ response, operationLocation: config === null || config === undefined ? undefined : config.operationLocation, resourceLocation: config === null || config === undefined ? undefined : config.resourceLocation }, (config === null || config === undefined ? undefined : config.mode) ? { metadata: { mode: config.mode } } : {});
|
|
},
|
|
poll: lro.sendPollRequest
|
|
}, {
|
|
intervalInMs,
|
|
withOperationLocation,
|
|
restoreFrom,
|
|
updateState,
|
|
processResult: processResult ? ({ flatResponse }, state) => processResult(flatResponse, state) : ({ flatResponse }) => flatResponse
|
|
});
|
|
}
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var logger$1 = require_dist3();
|
|
var abortController = require_dist();
|
|
var coreUtil = require_dist2();
|
|
var logger = logger$1.createClientLogger("core-lro");
|
|
var POLL_INTERVAL_IN_MS = 2000;
|
|
var terminalStates = ["succeeded", "canceled", "failed"];
|
|
var createStateProxy$1 = () => ({
|
|
initState: (config) => ({ status: "running", config }),
|
|
setCanceled: (state) => state.status = "canceled",
|
|
setError: (state, error) => state.error = error,
|
|
setResult: (state, result) => state.result = result,
|
|
setRunning: (state) => state.status = "running",
|
|
setSucceeded: (state) => state.status = "succeeded",
|
|
setFailed: (state) => state.status = "failed",
|
|
getError: (state) => state.error,
|
|
getResult: (state) => state.result,
|
|
isCanceled: (state) => state.status === "canceled",
|
|
isFailed: (state) => state.status === "failed",
|
|
isRunning: (state) => state.status === "running",
|
|
isSucceeded: (state) => state.status === "succeeded"
|
|
});
|
|
var createStateProxy = () => ({
|
|
initState: (config) => ({ config, isStarted: true }),
|
|
setCanceled: (state) => state.isCancelled = true,
|
|
setError: (state, error) => state.error = error,
|
|
setResult: (state, result) => state.result = result,
|
|
setRunning: (state) => state.isStarted = true,
|
|
setSucceeded: (state) => state.isCompleted = true,
|
|
setFailed: () => {
|
|
},
|
|
getError: (state) => state.error,
|
|
getResult: (state) => state.result,
|
|
isCanceled: (state) => !!state.isCancelled,
|
|
isFailed: (state) => !!state.error,
|
|
isRunning: (state) => !!state.isStarted,
|
|
isSucceeded: (state) => Boolean(state.isCompleted && !state.isCancelled && !state.error)
|
|
});
|
|
|
|
class GenericPollOperation {
|
|
constructor(state, lro, setErrorAsResult, lroResourceLocationConfig, processResult, updateState, isDone) {
|
|
this.state = state;
|
|
this.lro = lro;
|
|
this.setErrorAsResult = setErrorAsResult;
|
|
this.lroResourceLocationConfig = lroResourceLocationConfig;
|
|
this.processResult = processResult;
|
|
this.updateState = updateState;
|
|
this.isDone = isDone;
|
|
}
|
|
setPollerConfig(pollerConfig) {
|
|
this.pollerConfig = pollerConfig;
|
|
}
|
|
async update(options) {
|
|
var _a;
|
|
const stateProxy = createStateProxy();
|
|
if (!this.state.isStarted)
|
|
this.state = Object.assign(Object.assign({}, this.state), await initHttpOperation({
|
|
lro: this.lro,
|
|
stateProxy,
|
|
resourceLocationConfig: this.lroResourceLocationConfig,
|
|
processResult: this.processResult,
|
|
setErrorAsResult: this.setErrorAsResult
|
|
}));
|
|
const updateState = this.updateState;
|
|
const isDone = this.isDone;
|
|
if (!this.state.isCompleted && this.state.error === undefined)
|
|
await pollHttpOperation({
|
|
lro: this.lro,
|
|
state: this.state,
|
|
stateProxy,
|
|
processResult: this.processResult,
|
|
updateState: updateState ? (state, { rawResponse }) => updateState(state, rawResponse) : undefined,
|
|
isDone: isDone ? ({ flatResponse }, state) => isDone(flatResponse, state) : undefined,
|
|
options,
|
|
setDelay: (intervalInMs) => {
|
|
this.pollerConfig.intervalInMs = intervalInMs;
|
|
},
|
|
setErrorAsResult: this.setErrorAsResult
|
|
});
|
|
(_a = options === null || options === undefined ? undefined : options.fireProgress) === null || _a === undefined || _a.call(options, this.state);
|
|
return this;
|
|
}
|
|
async cancel() {
|
|
logger.error("`cancelOperation` is deprecated because it wasn't implemented");
|
|
return this;
|
|
}
|
|
toString() {
|
|
return JSON.stringify({
|
|
state: this.state
|
|
});
|
|
}
|
|
}
|
|
|
|
class PollerStoppedError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "PollerStoppedError";
|
|
Object.setPrototypeOf(this, PollerStoppedError.prototype);
|
|
}
|
|
}
|
|
|
|
class PollerCancelledError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "PollerCancelledError";
|
|
Object.setPrototypeOf(this, PollerCancelledError.prototype);
|
|
}
|
|
}
|
|
|
|
class Poller {
|
|
constructor(operation) {
|
|
this.resolveOnUnsuccessful = false;
|
|
this.stopped = true;
|
|
this.pollProgressCallbacks = [];
|
|
this.operation = operation;
|
|
this.promise = new Promise((resolve, reject) => {
|
|
this.resolve = resolve;
|
|
this.reject = reject;
|
|
});
|
|
this.promise.catch(() => {
|
|
});
|
|
}
|
|
async startPolling(pollOptions = {}) {
|
|
if (this.stopped)
|
|
this.stopped = false;
|
|
while (!this.isStopped() && !this.isDone()) {
|
|
await this.poll(pollOptions);
|
|
await this.delay();
|
|
}
|
|
}
|
|
async pollOnce(options = {}) {
|
|
if (!this.isDone())
|
|
this.operation = await this.operation.update({
|
|
abortSignal: options.abortSignal,
|
|
fireProgress: this.fireProgress.bind(this)
|
|
});
|
|
this.processUpdatedState();
|
|
}
|
|
fireProgress(state) {
|
|
for (const callback of this.pollProgressCallbacks)
|
|
callback(state);
|
|
}
|
|
async cancelOnce(options = {}) {
|
|
this.operation = await this.operation.cancel(options);
|
|
}
|
|
poll(options = {}) {
|
|
if (!this.pollOncePromise) {
|
|
this.pollOncePromise = this.pollOnce(options);
|
|
const clearPollOncePromise = () => {
|
|
this.pollOncePromise = undefined;
|
|
};
|
|
this.pollOncePromise.then(clearPollOncePromise, clearPollOncePromise).catch(this.reject);
|
|
}
|
|
return this.pollOncePromise;
|
|
}
|
|
processUpdatedState() {
|
|
if (this.operation.state.error) {
|
|
this.stopped = true;
|
|
if (!this.resolveOnUnsuccessful) {
|
|
this.reject(this.operation.state.error);
|
|
throw this.operation.state.error;
|
|
}
|
|
}
|
|
if (this.operation.state.isCancelled) {
|
|
this.stopped = true;
|
|
if (!this.resolveOnUnsuccessful) {
|
|
const error = new PollerCancelledError("Operation was canceled");
|
|
this.reject(error);
|
|
throw error;
|
|
}
|
|
}
|
|
if (this.isDone() && this.resolve)
|
|
this.resolve(this.getResult());
|
|
}
|
|
async pollUntilDone(pollOptions = {}) {
|
|
if (this.stopped)
|
|
this.startPolling(pollOptions).catch(this.reject);
|
|
this.processUpdatedState();
|
|
return this.promise;
|
|
}
|
|
onProgress(callback) {
|
|
this.pollProgressCallbacks.push(callback);
|
|
return () => {
|
|
this.pollProgressCallbacks = this.pollProgressCallbacks.filter((c) => c !== callback);
|
|
};
|
|
}
|
|
isDone() {
|
|
const state = this.operation.state;
|
|
return Boolean(state.isCompleted || state.isCancelled || state.error);
|
|
}
|
|
stopPolling() {
|
|
if (!this.stopped) {
|
|
this.stopped = true;
|
|
if (this.reject)
|
|
this.reject(new PollerStoppedError("This poller is already stopped"));
|
|
}
|
|
}
|
|
isStopped() {
|
|
return this.stopped;
|
|
}
|
|
cancelOperation(options = {}) {
|
|
if (!this.cancelPromise)
|
|
this.cancelPromise = this.cancelOnce(options);
|
|
else if (options.abortSignal)
|
|
throw new Error("A cancel request is currently pending");
|
|
return this.cancelPromise;
|
|
}
|
|
getOperationState() {
|
|
return this.operation.state;
|
|
}
|
|
getResult() {
|
|
const state = this.operation.state;
|
|
return state.result;
|
|
}
|
|
toString() {
|
|
return this.operation.toString();
|
|
}
|
|
}
|
|
|
|
class LroEngine extends Poller {
|
|
constructor(lro, options) {
|
|
const { intervalInMs = POLL_INTERVAL_IN_MS, resumeFrom, resolveOnUnsuccessful = false, isDone, lroResourceLocationConfig, processResult, updateState } = options || {};
|
|
const state = resumeFrom ? deserializeState(resumeFrom) : {};
|
|
const operation = new GenericPollOperation(state, lro, !resolveOnUnsuccessful, lroResourceLocationConfig, processResult, updateState, isDone);
|
|
super(operation);
|
|
this.resolveOnUnsuccessful = resolveOnUnsuccessful;
|
|
this.config = { intervalInMs };
|
|
operation.setPollerConfig(this.config);
|
|
}
|
|
delay() {
|
|
return new Promise((resolve) => setTimeout(() => resolve(), this.config.intervalInMs));
|
|
}
|
|
}
|
|
exports.LroEngine = LroEngine;
|
|
exports.Poller = Poller;
|
|
exports.PollerCancelledError = PollerCancelledError;
|
|
exports.PollerStoppedError = PollerStoppedError;
|
|
exports.createHttpPoller = createHttpPoller;
|
|
});
|
|
|
|
// node_modules/@azure/storage-blob/dist/index.js
|
|
var require_dist9 = __commonJS((exports) => {
|
|
var _interopNamespace = function(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 escapeURLPath = function(url2) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
let path = urlParsed.getPath();
|
|
path = path || "/";
|
|
path = escape(path);
|
|
urlParsed.setPath(path);
|
|
return urlParsed.toString();
|
|
};
|
|
var getProxyUriFromDevConnString = function(connectionString) {
|
|
let proxyUri = "";
|
|
if (connectionString.search("DevelopmentStorageProxyUri=") !== -1) {
|
|
const matchCredentials = connectionString.split(";");
|
|
for (const element of matchCredentials)
|
|
if (element.trim().startsWith("DevelopmentStorageProxyUri="))
|
|
proxyUri = element.trim().match("DevelopmentStorageProxyUri=(.*)")[1];
|
|
}
|
|
return proxyUri;
|
|
};
|
|
var getValueInConnString = function(connectionString, argument) {
|
|
const elements = connectionString.split(";");
|
|
for (const element of elements)
|
|
if (element.trim().startsWith(argument))
|
|
return element.trim().match(argument + "=(.*)")[1];
|
|
return "";
|
|
};
|
|
var extractConnectionStringParts = function(connectionString) {
|
|
let proxyUri = "";
|
|
if (connectionString.startsWith("UseDevelopmentStorage=true")) {
|
|
proxyUri = getProxyUriFromDevConnString(connectionString);
|
|
connectionString = DevelopmentConnectionString;
|
|
}
|
|
let blobEndpoint = getValueInConnString(connectionString, "BlobEndpoint");
|
|
blobEndpoint = blobEndpoint.endsWith("/") ? blobEndpoint.slice(0, -1) : blobEndpoint;
|
|
if (connectionString.search("DefaultEndpointsProtocol=") !== -1 && connectionString.search("AccountKey=") !== -1) {
|
|
let defaultEndpointsProtocol = "";
|
|
let accountName = "";
|
|
let accountKey = Buffer.from("accountKey", "base64");
|
|
let endpointSuffix = "";
|
|
accountName = getValueInConnString(connectionString, "AccountName");
|
|
accountKey = Buffer.from(getValueInConnString(connectionString, "AccountKey"), "base64");
|
|
if (!blobEndpoint) {
|
|
defaultEndpointsProtocol = getValueInConnString(connectionString, "DefaultEndpointsProtocol");
|
|
const protocol = defaultEndpointsProtocol.toLowerCase();
|
|
if (protocol !== "https" && protocol !== "http")
|
|
throw new Error("Invalid DefaultEndpointsProtocol in the provided Connection String. Expecting 'https' or 'http'");
|
|
endpointSuffix = getValueInConnString(connectionString, "EndpointSuffix");
|
|
if (!endpointSuffix)
|
|
throw new Error("Invalid EndpointSuffix in the provided Connection String");
|
|
blobEndpoint = `${defaultEndpointsProtocol}://${accountName}.blob.${endpointSuffix}`;
|
|
}
|
|
if (!accountName)
|
|
throw new Error("Invalid AccountName in the provided Connection String");
|
|
else if (accountKey.length === 0)
|
|
throw new Error("Invalid AccountKey in the provided Connection String");
|
|
return {
|
|
kind: "AccountConnString",
|
|
url: blobEndpoint,
|
|
accountName,
|
|
accountKey,
|
|
proxyUri
|
|
};
|
|
} else {
|
|
const accountSas = getValueInConnString(connectionString, "SharedAccessSignature");
|
|
const accountName = getAccountNameFromUrl(blobEndpoint);
|
|
if (!blobEndpoint)
|
|
throw new Error("Invalid BlobEndpoint in the provided SAS Connection String");
|
|
else if (!accountSas)
|
|
throw new Error("Invalid SharedAccessSignature in the provided SAS Connection String");
|
|
return { kind: "SASConnString", url: blobEndpoint, accountName, accountSas };
|
|
}
|
|
};
|
|
var escape = function(text) {
|
|
return encodeURIComponent(text).replace(/%2F/g, "/").replace(/'/g, "%27").replace(/\+/g, "%20").replace(/%25/g, "%");
|
|
};
|
|
var appendToURLPath = function(url2, name) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
let path = urlParsed.getPath();
|
|
path = path ? path.endsWith("/") ? `${path}${name}` : `${path}/${name}` : name;
|
|
urlParsed.setPath(path);
|
|
const normalizedUrl = new URL(urlParsed.toString());
|
|
return normalizedUrl.toString();
|
|
};
|
|
var setURLParameter = function(url2, name, value) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
urlParsed.setQueryParameter(name, value);
|
|
return urlParsed.toString();
|
|
};
|
|
var getURLParameter = function(url2, name) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
return urlParsed.getQueryParameterValue(name);
|
|
};
|
|
var setURLHost = function(url2, host) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
urlParsed.setHost(host);
|
|
return urlParsed.toString();
|
|
};
|
|
var getURLPath = function(url2) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
return urlParsed.getPath();
|
|
};
|
|
var getURLScheme = function(url2) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
return urlParsed.getScheme();
|
|
};
|
|
var getURLPathAndQuery = function(url2) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
const pathString = urlParsed.getPath();
|
|
if (!pathString)
|
|
throw new RangeError("Invalid url without valid path.");
|
|
let queryString = urlParsed.getQuery() || "";
|
|
queryString = queryString.trim();
|
|
if (queryString !== "")
|
|
queryString = queryString.startsWith("?") ? queryString : `?${queryString}`;
|
|
return `${pathString}${queryString}`;
|
|
};
|
|
var getURLQueries = function(url2) {
|
|
let queryString = coreHttp.URLBuilder.parse(url2).getQuery();
|
|
if (!queryString)
|
|
return {};
|
|
queryString = queryString.trim();
|
|
queryString = queryString.startsWith("?") ? queryString.substr(1) : queryString;
|
|
let querySubStrings = queryString.split("&");
|
|
querySubStrings = querySubStrings.filter((value) => {
|
|
const indexOfEqual = value.indexOf("=");
|
|
const lastIndexOfEqual = value.lastIndexOf("=");
|
|
return indexOfEqual > 0 && indexOfEqual === lastIndexOfEqual && lastIndexOfEqual < value.length - 1;
|
|
});
|
|
const queries = {};
|
|
for (const querySubString of querySubStrings) {
|
|
const splitResults = querySubString.split("=");
|
|
const key = splitResults[0];
|
|
const value = splitResults[1];
|
|
queries[key] = value;
|
|
}
|
|
return queries;
|
|
};
|
|
var appendToURLQuery = function(url2, queryParts) {
|
|
const urlParsed = coreHttp.URLBuilder.parse(url2);
|
|
let query = urlParsed.getQuery();
|
|
if (query)
|
|
query += "&" + queryParts;
|
|
else
|
|
query = queryParts;
|
|
urlParsed.setQuery(query);
|
|
return urlParsed.toString();
|
|
};
|
|
var truncatedISO8061Date = function(date, withMilliseconds = true) {
|
|
const dateString = date.toISOString();
|
|
return withMilliseconds ? dateString.substring(0, dateString.length - 1) + "0000Z" : dateString.substring(0, dateString.length - 5) + "Z";
|
|
};
|
|
var base64encode = function(content) {
|
|
return !coreHttp.isNode ? btoa(content) : Buffer.from(content).toString("base64");
|
|
};
|
|
var generateBlockID = function(blockIDPrefix, blockIndex) {
|
|
const maxSourceStringLength = 48;
|
|
const maxBlockIndexLength = 6;
|
|
const maxAllowedBlockIDPrefixLength = maxSourceStringLength - maxBlockIndexLength;
|
|
if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength)
|
|
blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
|
|
const res = blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
|
|
return base64encode(res);
|
|
};
|
|
async function delay(timeInMs, aborter, abortError) {
|
|
return new Promise((resolve, reject) => {
|
|
let timeout;
|
|
const abortHandler = () => {
|
|
if (timeout !== undefined)
|
|
clearTimeout(timeout);
|
|
reject(abortError);
|
|
};
|
|
const resolveHandler = () => {
|
|
if (aborter !== undefined)
|
|
aborter.removeEventListener("abort", abortHandler);
|
|
resolve();
|
|
};
|
|
timeout = setTimeout(resolveHandler, timeInMs);
|
|
if (aborter !== undefined)
|
|
aborter.addEventListener("abort", abortHandler);
|
|
});
|
|
}
|
|
var padStart = function(currentString, targetLength, padString = " ") {
|
|
if (String.prototype.padStart)
|
|
return currentString.padStart(targetLength, padString);
|
|
padString = padString || " ";
|
|
if (currentString.length > targetLength)
|
|
return currentString;
|
|
else {
|
|
targetLength = targetLength - currentString.length;
|
|
if (targetLength > padString.length)
|
|
padString += padString.repeat(targetLength / padString.length);
|
|
return padString.slice(0, targetLength) + currentString;
|
|
}
|
|
};
|
|
var iEqual = function(str1, str2) {
|
|
return str1.toLocaleLowerCase() === str2.toLocaleLowerCase();
|
|
};
|
|
var getAccountNameFromUrl = function(url2) {
|
|
const parsedUrl = coreHttp.URLBuilder.parse(url2);
|
|
let accountName;
|
|
try {
|
|
if (parsedUrl.getHost().split(".")[1] === "blob")
|
|
accountName = parsedUrl.getHost().split(".")[0];
|
|
else if (isIpEndpointStyle(parsedUrl))
|
|
accountName = parsedUrl.getPath().split("/")[1];
|
|
else
|
|
accountName = "";
|
|
return accountName;
|
|
} catch (error) {
|
|
throw new Error("Unable to extract accountName with provided information.");
|
|
}
|
|
};
|
|
var isIpEndpointStyle = function(parsedUrl) {
|
|
if (parsedUrl.getHost() === undefined)
|
|
return false;
|
|
const host = parsedUrl.getHost() + (parsedUrl.getPort() === undefined ? "" : ":" + parsedUrl.getPort());
|
|
return /^.*:.*:.*$|^localhost(:[0-9]+)?$|^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])(\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])){3}(:[0-9]+)?$/.test(host) || parsedUrl.getPort() !== undefined && PathStylePorts.includes(parsedUrl.getPort());
|
|
};
|
|
var toBlobTagsString = function(tags2) {
|
|
if (tags2 === undefined)
|
|
return;
|
|
const tagPairs = [];
|
|
for (const key in tags2)
|
|
if (Object.prototype.hasOwnProperty.call(tags2, key)) {
|
|
const value = tags2[key];
|
|
tagPairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
|
|
}
|
|
return tagPairs.join("&");
|
|
};
|
|
var toBlobTags = function(tags2) {
|
|
if (tags2 === undefined)
|
|
return;
|
|
const res = {
|
|
blobTagSet: []
|
|
};
|
|
for (const key in tags2)
|
|
if (Object.prototype.hasOwnProperty.call(tags2, key)) {
|
|
const value = tags2[key];
|
|
res.blobTagSet.push({
|
|
key,
|
|
value
|
|
});
|
|
}
|
|
return res;
|
|
};
|
|
var toTags = function(tags2) {
|
|
if (tags2 === undefined)
|
|
return;
|
|
const res = {};
|
|
for (const blobTag of tags2.blobTagSet)
|
|
res[blobTag.key] = blobTag.value;
|
|
return res;
|
|
};
|
|
var toQuerySerialization = function(textConfiguration) {
|
|
if (textConfiguration === undefined)
|
|
return;
|
|
switch (textConfiguration.kind) {
|
|
case "csv":
|
|
return {
|
|
format: {
|
|
type: "delimited",
|
|
delimitedTextConfiguration: {
|
|
columnSeparator: textConfiguration.columnSeparator || ",",
|
|
fieldQuote: textConfiguration.fieldQuote || "",
|
|
recordSeparator: textConfiguration.recordSeparator,
|
|
escapeChar: textConfiguration.escapeCharacter || "",
|
|
headersPresent: textConfiguration.hasHeaders || false
|
|
}
|
|
}
|
|
};
|
|
case "json":
|
|
return {
|
|
format: {
|
|
type: "json",
|
|
jsonTextConfiguration: {
|
|
recordSeparator: textConfiguration.recordSeparator
|
|
}
|
|
}
|
|
};
|
|
case "arrow":
|
|
return {
|
|
format: {
|
|
type: "arrow",
|
|
arrowConfiguration: {
|
|
schema: textConfiguration.schema
|
|
}
|
|
}
|
|
};
|
|
case "parquet":
|
|
return {
|
|
format: {
|
|
type: "parquet"
|
|
}
|
|
};
|
|
default:
|
|
throw Error("Invalid BlobQueryTextConfiguration.");
|
|
}
|
|
};
|
|
var parseObjectReplicationRecord = function(objectReplicationRecord) {
|
|
if (!objectReplicationRecord)
|
|
return;
|
|
if ("policy-id" in objectReplicationRecord)
|
|
return;
|
|
const orProperties = [];
|
|
for (const key in objectReplicationRecord) {
|
|
const ids = key.split("_");
|
|
const policyPrefix = "or-";
|
|
if (ids[0].startsWith(policyPrefix))
|
|
ids[0] = ids[0].substring(policyPrefix.length);
|
|
const rule = {
|
|
ruleId: ids[1],
|
|
replicationStatus: objectReplicationRecord[key]
|
|
};
|
|
const policyIndex = orProperties.findIndex((policy) => policy.policyId === ids[0]);
|
|
if (policyIndex > -1)
|
|
orProperties[policyIndex].rules.push(rule);
|
|
else
|
|
orProperties.push({
|
|
policyId: ids[0],
|
|
rules: [rule]
|
|
});
|
|
}
|
|
return orProperties;
|
|
};
|
|
var attachCredential = function(thing, credential) {
|
|
thing.credential = credential;
|
|
return thing;
|
|
};
|
|
var httpAuthorizationToString = function(httpAuthorization) {
|
|
return httpAuthorization ? httpAuthorization.scheme + " " + httpAuthorization.value : undefined;
|
|
};
|
|
var BlobNameToString = function(name) {
|
|
if (name.encoded)
|
|
return decodeURIComponent(name.content);
|
|
else
|
|
return name.content;
|
|
};
|
|
var ConvertInternalResponseOfListBlobFlat = function(internalResponse) {
|
|
return Object.assign(Object.assign({}, internalResponse), { segment: {
|
|
blobItems: internalResponse.segment.blobItems.map((blobItemInteral) => {
|
|
const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name) });
|
|
return blobItem;
|
|
})
|
|
} });
|
|
};
|
|
var ConvertInternalResponseOfListBlobHierarchy = function(internalResponse) {
|
|
var _a;
|
|
return Object.assign(Object.assign({}, internalResponse), { segment: {
|
|
blobPrefixes: (_a = internalResponse.segment.blobPrefixes) === null || _a === undefined ? undefined : _a.map((blobPrefixInternal) => {
|
|
const blobPrefix = {
|
|
name: BlobNameToString(blobPrefixInternal.name)
|
|
};
|
|
return blobPrefix;
|
|
}),
|
|
blobItems: internalResponse.segment.blobItems.map((blobItemInteral) => {
|
|
const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name) });
|
|
return blobItem;
|
|
})
|
|
} });
|
|
};
|
|
function* ExtractPageRangeInfoItems(getPageRangesSegment) {
|
|
let pageRange = [];
|
|
let clearRange = [];
|
|
if (getPageRangesSegment.pageRange)
|
|
pageRange = getPageRangesSegment.pageRange;
|
|
if (getPageRangesSegment.clearRange)
|
|
clearRange = getPageRangesSegment.clearRange;
|
|
let pageRangeIndex = 0;
|
|
let clearRangeIndex = 0;
|
|
while (pageRangeIndex < pageRange.length && clearRangeIndex < clearRange.length)
|
|
if (pageRange[pageRangeIndex].start < clearRange[clearRangeIndex].start) {
|
|
yield {
|
|
start: pageRange[pageRangeIndex].start,
|
|
end: pageRange[pageRangeIndex].end,
|
|
isClear: false
|
|
};
|
|
++pageRangeIndex;
|
|
} else {
|
|
yield {
|
|
start: clearRange[clearRangeIndex].start,
|
|
end: clearRange[clearRangeIndex].end,
|
|
isClear: true
|
|
};
|
|
++clearRangeIndex;
|
|
}
|
|
for (;pageRangeIndex < pageRange.length; ++pageRangeIndex)
|
|
yield {
|
|
start: pageRange[pageRangeIndex].start,
|
|
end: pageRange[pageRangeIndex].end,
|
|
isClear: false
|
|
};
|
|
for (;clearRangeIndex < clearRange.length; ++clearRangeIndex)
|
|
yield {
|
|
start: clearRange[clearRangeIndex].start,
|
|
end: clearRange[clearRangeIndex].end,
|
|
isClear: true
|
|
};
|
|
}
|
|
var EscapePath = function(blobName) {
|
|
const split = blobName.split("/");
|
|
for (let i = 0;i < split.length; i++)
|
|
split[i] = encodeURIComponent(split[i]);
|
|
return split.join("/");
|
|
};
|
|
var getCachedDefaultHttpClient = function() {
|
|
return _defaultHttpClient;
|
|
};
|
|
async function beginRefresh(getAccessToken, retryIntervalInMs, timeoutInMs) {
|
|
async function tryGetAccessToken() {
|
|
if (Date.now() < timeoutInMs)
|
|
try {
|
|
return await getAccessToken();
|
|
} catch (_a) {
|
|
return null;
|
|
}
|
|
else {
|
|
const finalToken = await getAccessToken();
|
|
if (finalToken === null)
|
|
throw new Error("Failed to refresh access token.");
|
|
return finalToken;
|
|
}
|
|
}
|
|
let token = await tryGetAccessToken();
|
|
while (token === null) {
|
|
await coreHttp.delay(retryIntervalInMs);
|
|
token = await tryGetAccessToken();
|
|
}
|
|
return token;
|
|
}
|
|
var createTokenCycler = function(credential, scopes, tokenCyclerOptions) {
|
|
let refreshWorker = null;
|
|
let token = null;
|
|
const options = Object.assign(Object.assign({}, DEFAULT_CYCLER_OPTIONS), tokenCyclerOptions);
|
|
const cycler = {
|
|
get isRefreshing() {
|
|
return refreshWorker !== null;
|
|
},
|
|
get shouldRefresh() {
|
|
var _a;
|
|
return !cycler.isRefreshing && ((_a = token === null || token === undefined ? undefined : token.expiresOnTimestamp) !== null && _a !== undefined ? _a : 0) - options.refreshWindowInMs < Date.now();
|
|
},
|
|
get mustRefresh() {
|
|
return token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now();
|
|
}
|
|
};
|
|
function refresh(getTokenOptions) {
|
|
var _a;
|
|
if (!cycler.isRefreshing) {
|
|
const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
|
|
refreshWorker = beginRefresh(tryGetAccessToken, options.retryIntervalInMs, (_a = token === null || token === undefined ? undefined : token.expiresOnTimestamp) !== null && _a !== undefined ? _a : Date.now()).then((_token) => {
|
|
refreshWorker = null;
|
|
token = _token;
|
|
return token;
|
|
}).catch((reason) => {
|
|
refreshWorker = null;
|
|
token = null;
|
|
throw reason;
|
|
});
|
|
}
|
|
return refreshWorker;
|
|
}
|
|
return async (tokenOptions) => {
|
|
if (cycler.mustRefresh)
|
|
return refresh(tokenOptions);
|
|
if (cycler.shouldRefresh)
|
|
refresh(tokenOptions);
|
|
return token;
|
|
};
|
|
};
|
|
var getChallenge = function(response) {
|
|
const challenge = response.headers.get("WWW-Authenticate");
|
|
if (response.status === 401 && challenge)
|
|
return challenge;
|
|
return;
|
|
};
|
|
var parseChallenge = function(challenge) {
|
|
const bearerChallenge = challenge.slice("Bearer ".length);
|
|
const challengeParts = `${bearerChallenge.trim()} `.split(" ").filter((x) => x);
|
|
const keyValuePairs = challengeParts.map((keyValue) => (([key, value]) => ({ [key]: value }))(keyValue.trim().split("=")));
|
|
return keyValuePairs.reduce((a, b) => Object.assign(Object.assign({}, a), b), {});
|
|
};
|
|
var storageBearerTokenChallengeAuthenticationPolicy = function(credential, scopes) {
|
|
let getToken = createTokenCycler(credential, scopes);
|
|
|
|
class StorageBearerTokenChallengeAuthenticationPolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(webResource) {
|
|
if (!webResource.url.toLowerCase().startsWith("https://"))
|
|
throw new Error("Bearer token authentication is not permitted for non-TLS protected (non-https) URLs.");
|
|
const getTokenInternal = getToken;
|
|
const token = (await getTokenInternal({
|
|
abortSignal: webResource.abortSignal,
|
|
tracingOptions: {
|
|
tracingContext: webResource.tracingContext
|
|
}
|
|
})).token;
|
|
webResource.headers.set(Constants.HeaderConstants.AUTHORIZATION, `Bearer ${token}`);
|
|
const response = await this._nextPolicy.sendRequest(webResource);
|
|
if ((response === null || response === undefined ? undefined : response.status) === 401) {
|
|
const challenge = getChallenge(response);
|
|
if (challenge) {
|
|
const challengeInfo = parseChallenge(challenge);
|
|
const challengeScopes = challengeInfo.resource_id + Constants.DefaultScope;
|
|
const parsedAuthUri = coreHttp.URLBuilder.parse(challengeInfo.authorization_uri);
|
|
const pathSegments = parsedAuthUri.getPath().split("/");
|
|
const tenantId = pathSegments[1];
|
|
const getTokenForChallenge = createTokenCycler(credential, challengeScopes);
|
|
const tokenForChallenge = (await getTokenForChallenge({
|
|
abortSignal: webResource.abortSignal,
|
|
tracingOptions: {
|
|
tracingContext: webResource.tracingContext
|
|
},
|
|
tenantId
|
|
})).token;
|
|
getToken = getTokenForChallenge;
|
|
webResource.headers.set(Constants.HeaderConstants.AUTHORIZATION, `Bearer ${tokenForChallenge}`);
|
|
return this._nextPolicy.sendRequest(webResource);
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
}
|
|
return {
|
|
create: (nextPolicy, options) => {
|
|
return new StorageBearerTokenChallengeAuthenticationPolicy(nextPolicy, options);
|
|
}
|
|
};
|
|
};
|
|
var isPipelineLike = function(pipeline) {
|
|
if (!pipeline || typeof pipeline !== "object")
|
|
return false;
|
|
const castPipeline = pipeline;
|
|
return Array.isArray(castPipeline.factories) && typeof castPipeline.options === "object" && typeof castPipeline.toServiceClientOptions === "function";
|
|
};
|
|
var newPipeline = function(credential, pipelineOptions = {}) {
|
|
var _a;
|
|
if (credential === undefined)
|
|
credential = new AnonymousCredential;
|
|
const telemetryPolicy = new TelemetryPolicyFactory(pipelineOptions.userAgentOptions);
|
|
const factories = [
|
|
coreHttp.tracingPolicy({ userAgent: telemetryPolicy.telemetryString }),
|
|
coreHttp.keepAlivePolicy(pipelineOptions.keepAliveOptions),
|
|
telemetryPolicy,
|
|
coreHttp.generateClientRequestIdPolicy(),
|
|
new StorageBrowserPolicyFactory,
|
|
new StorageRetryPolicyFactory(pipelineOptions.retryOptions),
|
|
coreHttp.deserializationPolicy(undefined, { xmlCharKey: "#" }),
|
|
coreHttp.logPolicy({
|
|
logger: logger.info,
|
|
allowedHeaderNames: StorageBlobLoggingAllowedHeaderNames,
|
|
allowedQueryParameters: StorageBlobLoggingAllowedQueryParameters
|
|
})
|
|
];
|
|
if (coreHttp.isNode) {
|
|
factories.push(coreHttp.proxyPolicy(pipelineOptions.proxyOptions));
|
|
factories.push(coreHttp.disableResponseDecompressionPolicy());
|
|
}
|
|
factories.push(coreHttp.isTokenCredential(credential) ? attachCredential(storageBearerTokenChallengeAuthenticationPolicy(credential, (_a = pipelineOptions.audience) !== null && _a !== undefined ? _a : StorageOAuthScopes), credential) : credential);
|
|
return new Pipeline(factories, pipelineOptions);
|
|
};
|
|
var convertTracingToRequestOptionsBase = function(options) {
|
|
var _a, _b;
|
|
return {
|
|
spanOptions: (_a = options === null || options === undefined ? undefined : options.tracingOptions) === null || _a === undefined ? undefined : _a.spanOptions,
|
|
tracingContext: (_b = options === null || options === undefined ? undefined : options.tracingOptions) === null || _b === undefined ? undefined : _b.tracingContext
|
|
};
|
|
};
|
|
var ipRangeToString = function(ipRange) {
|
|
return ipRange.end ? `${ipRange.start}-${ipRange.end}` : ipRange.start;
|
|
};
|
|
var generateBlobSASQueryParameters = function(blobSASSignatureValues, sharedKeyCredentialOrUserDelegationKey, accountName) {
|
|
const version4 = blobSASSignatureValues.version ? blobSASSignatureValues.version : SERVICE_VERSION;
|
|
const sharedKeyCredential = sharedKeyCredentialOrUserDelegationKey instanceof StorageSharedKeyCredential ? sharedKeyCredentialOrUserDelegationKey : undefined;
|
|
let userDelegationKeyCredential;
|
|
if (sharedKeyCredential === undefined && accountName !== undefined)
|
|
userDelegationKeyCredential = new UserDelegationKeyCredential(accountName, sharedKeyCredentialOrUserDelegationKey);
|
|
if (sharedKeyCredential === undefined && userDelegationKeyCredential === undefined)
|
|
throw TypeError("Invalid sharedKeyCredential, userDelegationKey or accountName.");
|
|
if (version4 >= "2020-12-06")
|
|
if (sharedKeyCredential !== undefined)
|
|
return generateBlobSASQueryParameters20201206(blobSASSignatureValues, sharedKeyCredential);
|
|
else
|
|
return generateBlobSASQueryParametersUDK20201206(blobSASSignatureValues, userDelegationKeyCredential);
|
|
if (version4 >= "2018-11-09")
|
|
if (sharedKeyCredential !== undefined)
|
|
return generateBlobSASQueryParameters20181109(blobSASSignatureValues, sharedKeyCredential);
|
|
else if (version4 >= "2020-02-10")
|
|
return generateBlobSASQueryParametersUDK20200210(blobSASSignatureValues, userDelegationKeyCredential);
|
|
else
|
|
return generateBlobSASQueryParametersUDK20181109(blobSASSignatureValues, userDelegationKeyCredential);
|
|
if (version4 >= "2015-04-05")
|
|
if (sharedKeyCredential !== undefined)
|
|
return generateBlobSASQueryParameters20150405(blobSASSignatureValues, sharedKeyCredential);
|
|
else
|
|
throw new RangeError("'version' must be >= '2018-11-09' when generating user delegation SAS using user delegation key.");
|
|
throw new RangeError("'version' must be >= '2015-04-05'.");
|
|
};
|
|
var generateBlobSASQueryParameters20150405 = function(blobSASSignatureValues, sharedKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn))
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
|
|
let resource = "c";
|
|
if (blobSASSignatureValues.blobName)
|
|
resource = "b";
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
blobSASSignatureValues.identifier,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
|
|
blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
|
|
blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
|
|
blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
|
|
blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
|
|
].join("\n");
|
|
const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType);
|
|
};
|
|
var generateBlobSASQueryParameters20181109 = function(blobSASSignatureValues, sharedKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn))
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
|
|
let resource = "c";
|
|
let timestamp = blobSASSignatureValues.snapshotTime;
|
|
if (blobSASSignatureValues.blobName) {
|
|
resource = "b";
|
|
if (blobSASSignatureValues.snapshotTime)
|
|
resource = "bs";
|
|
else if (blobSASSignatureValues.versionId) {
|
|
resource = "bv";
|
|
timestamp = blobSASSignatureValues.versionId;
|
|
}
|
|
}
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
blobSASSignatureValues.identifier,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
resource,
|
|
timestamp,
|
|
blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
|
|
blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
|
|
blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
|
|
blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
|
|
blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
|
|
].join("\n");
|
|
const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType);
|
|
};
|
|
var generateBlobSASQueryParameters20201206 = function(blobSASSignatureValues, sharedKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.identifier && !(blobSASSignatureValues.permissions && blobSASSignatureValues.expiresOn))
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
|
|
let resource = "c";
|
|
let timestamp = blobSASSignatureValues.snapshotTime;
|
|
if (blobSASSignatureValues.blobName) {
|
|
resource = "b";
|
|
if (blobSASSignatureValues.snapshotTime)
|
|
resource = "bs";
|
|
else if (blobSASSignatureValues.versionId) {
|
|
resource = "bv";
|
|
timestamp = blobSASSignatureValues.versionId;
|
|
}
|
|
}
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(sharedKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
blobSASSignatureValues.identifier,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
resource,
|
|
timestamp,
|
|
blobSASSignatureValues.encryptionScope,
|
|
blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
|
|
blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
|
|
blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
|
|
blobSASSignatureValues.contentLanguage ? blobSASSignatureValues.contentLanguage : "",
|
|
blobSASSignatureValues.contentType ? blobSASSignatureValues.contentType : ""
|
|
].join("\n");
|
|
const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, undefined, undefined, undefined, blobSASSignatureValues.encryptionScope);
|
|
};
|
|
var generateBlobSASQueryParametersUDK20181109 = function(blobSASSignatureValues, userDelegationKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn)
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
|
|
let resource = "c";
|
|
let timestamp = blobSASSignatureValues.snapshotTime;
|
|
if (blobSASSignatureValues.blobName) {
|
|
resource = "b";
|
|
if (blobSASSignatureValues.snapshotTime)
|
|
resource = "bs";
|
|
else if (blobSASSignatureValues.versionId) {
|
|
resource = "bv";
|
|
timestamp = blobSASSignatureValues.versionId;
|
|
}
|
|
}
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
userDelegationKeyCredential.userDelegationKey.signedObjectId,
|
|
userDelegationKeyCredential.userDelegationKey.signedTenantId,
|
|
userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedService,
|
|
userDelegationKeyCredential.userDelegationKey.signedVersion,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
resource,
|
|
timestamp,
|
|
blobSASSignatureValues.cacheControl,
|
|
blobSASSignatureValues.contentDisposition,
|
|
blobSASSignatureValues.contentEncoding,
|
|
blobSASSignatureValues.contentLanguage,
|
|
blobSASSignatureValues.contentType
|
|
].join("\n");
|
|
const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey);
|
|
};
|
|
var generateBlobSASQueryParametersUDK20200210 = function(blobSASSignatureValues, userDelegationKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn)
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
|
|
let resource = "c";
|
|
let timestamp = blobSASSignatureValues.snapshotTime;
|
|
if (blobSASSignatureValues.blobName) {
|
|
resource = "b";
|
|
if (blobSASSignatureValues.snapshotTime)
|
|
resource = "bs";
|
|
else if (blobSASSignatureValues.versionId) {
|
|
resource = "bv";
|
|
timestamp = blobSASSignatureValues.versionId;
|
|
}
|
|
}
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
userDelegationKeyCredential.userDelegationKey.signedObjectId,
|
|
userDelegationKeyCredential.userDelegationKey.signedTenantId,
|
|
userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedService,
|
|
userDelegationKeyCredential.userDelegationKey.signedVersion,
|
|
blobSASSignatureValues.preauthorizedAgentObjectId,
|
|
undefined,
|
|
blobSASSignatureValues.correlationId,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
resource,
|
|
timestamp,
|
|
blobSASSignatureValues.cacheControl,
|
|
blobSASSignatureValues.contentDisposition,
|
|
blobSASSignatureValues.contentEncoding,
|
|
blobSASSignatureValues.contentLanguage,
|
|
blobSASSignatureValues.contentType
|
|
].join("\n");
|
|
const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId);
|
|
};
|
|
var generateBlobSASQueryParametersUDK20201206 = function(blobSASSignatureValues, userDelegationKeyCredential) {
|
|
blobSASSignatureValues = SASSignatureValuesSanityCheckAndAutofill(blobSASSignatureValues);
|
|
if (!blobSASSignatureValues.permissions || !blobSASSignatureValues.expiresOn)
|
|
throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
|
|
let resource = "c";
|
|
let timestamp = blobSASSignatureValues.snapshotTime;
|
|
if (blobSASSignatureValues.blobName) {
|
|
resource = "b";
|
|
if (blobSASSignatureValues.snapshotTime)
|
|
resource = "bs";
|
|
else if (blobSASSignatureValues.versionId) {
|
|
resource = "bv";
|
|
timestamp = blobSASSignatureValues.versionId;
|
|
}
|
|
}
|
|
let verifiedPermissions;
|
|
if (blobSASSignatureValues.permissions)
|
|
if (blobSASSignatureValues.blobName)
|
|
verifiedPermissions = BlobSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
else
|
|
verifiedPermissions = ContainerSASPermissions.parse(blobSASSignatureValues.permissions.toString()).toString();
|
|
const stringToSign = [
|
|
verifiedPermissions ? verifiedPermissions : "",
|
|
blobSASSignatureValues.startsOn ? truncatedISO8061Date(blobSASSignatureValues.startsOn, false) : "",
|
|
blobSASSignatureValues.expiresOn ? truncatedISO8061Date(blobSASSignatureValues.expiresOn, false) : "",
|
|
getCanonicalName(userDelegationKeyCredential.accountName, blobSASSignatureValues.containerName, blobSASSignatureValues.blobName),
|
|
userDelegationKeyCredential.userDelegationKey.signedObjectId,
|
|
userDelegationKeyCredential.userDelegationKey.signedTenantId,
|
|
userDelegationKeyCredential.userDelegationKey.signedStartsOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedStartsOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedExpiresOn ? truncatedISO8061Date(userDelegationKeyCredential.userDelegationKey.signedExpiresOn, false) : "",
|
|
userDelegationKeyCredential.userDelegationKey.signedService,
|
|
userDelegationKeyCredential.userDelegationKey.signedVersion,
|
|
blobSASSignatureValues.preauthorizedAgentObjectId,
|
|
undefined,
|
|
blobSASSignatureValues.correlationId,
|
|
blobSASSignatureValues.ipRange ? ipRangeToString(blobSASSignatureValues.ipRange) : "",
|
|
blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
|
|
blobSASSignatureValues.version,
|
|
resource,
|
|
timestamp,
|
|
blobSASSignatureValues.encryptionScope,
|
|
blobSASSignatureValues.cacheControl,
|
|
blobSASSignatureValues.contentDisposition,
|
|
blobSASSignatureValues.contentEncoding,
|
|
blobSASSignatureValues.contentLanguage,
|
|
blobSASSignatureValues.contentType
|
|
].join("\n");
|
|
const signature = userDelegationKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(blobSASSignatureValues.version, signature, verifiedPermissions, undefined, undefined, blobSASSignatureValues.protocol, blobSASSignatureValues.startsOn, blobSASSignatureValues.expiresOn, blobSASSignatureValues.ipRange, blobSASSignatureValues.identifier, resource, blobSASSignatureValues.cacheControl, blobSASSignatureValues.contentDisposition, blobSASSignatureValues.contentEncoding, blobSASSignatureValues.contentLanguage, blobSASSignatureValues.contentType, userDelegationKeyCredential.userDelegationKey, blobSASSignatureValues.preauthorizedAgentObjectId, blobSASSignatureValues.correlationId, blobSASSignatureValues.encryptionScope);
|
|
};
|
|
var getCanonicalName = function(accountName, containerName, blobName) {
|
|
const elements = [`/blob/${accountName}/${containerName}`];
|
|
if (blobName)
|
|
elements.push(`/${blobName}`);
|
|
return elements.join("");
|
|
};
|
|
var SASSignatureValuesSanityCheckAndAutofill = function(blobSASSignatureValues) {
|
|
const version4 = blobSASSignatureValues.version ? blobSASSignatureValues.version : SERVICE_VERSION;
|
|
if (blobSASSignatureValues.snapshotTime && version4 < "2018-11-09")
|
|
throw RangeError("'version' must be >= '2018-11-09' when providing 'snapshotTime'.");
|
|
if (blobSASSignatureValues.blobName === undefined && blobSASSignatureValues.snapshotTime)
|
|
throw RangeError("Must provide 'blobName' when providing 'snapshotTime'.");
|
|
if (blobSASSignatureValues.versionId && version4 < "2019-10-10")
|
|
throw RangeError("'version' must be >= '2019-10-10' when providing 'versionId'.");
|
|
if (blobSASSignatureValues.blobName === undefined && blobSASSignatureValues.versionId)
|
|
throw RangeError("Must provide 'blobName' when providing 'versionId'.");
|
|
if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.setImmutabilityPolicy && version4 < "2020-08-04")
|
|
throw RangeError("'version' must be >= '2020-08-04' when provided 'i' permission.");
|
|
if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.deleteVersion && version4 < "2019-10-10")
|
|
throw RangeError("'version' must be >= '2019-10-10' when providing 'x' permission.");
|
|
if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.permanentDelete && version4 < "2019-10-10")
|
|
throw RangeError("'version' must be >= '2019-10-10' when providing 'y' permission.");
|
|
if (blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.tag && version4 < "2019-12-12")
|
|
throw RangeError("'version' must be >= '2019-12-12' when providing 't' permission.");
|
|
if (version4 < "2020-02-10" && blobSASSignatureValues.permissions && (blobSASSignatureValues.permissions.move || blobSASSignatureValues.permissions.execute))
|
|
throw RangeError("'version' must be >= '2020-02-10' when providing the 'm' or 'e' permission.");
|
|
if (version4 < "2021-04-10" && blobSASSignatureValues.permissions && blobSASSignatureValues.permissions.filterByTags)
|
|
throw RangeError("'version' must be >= '2021-04-10' when providing the 'f' permission.");
|
|
if (version4 < "2020-02-10" && (blobSASSignatureValues.preauthorizedAgentObjectId || blobSASSignatureValues.correlationId))
|
|
throw RangeError("'version' must be >= '2020-02-10' when providing 'preauthorizedAgentObjectId' or 'correlationId'.");
|
|
if (blobSASSignatureValues.encryptionScope && version4 < "2020-12-06")
|
|
throw RangeError("'version' must be >= '2020-12-06' when provided 'encryptionScope' in SAS.");
|
|
blobSASSignatureValues.version = version4;
|
|
return blobSASSignatureValues;
|
|
};
|
|
var arraysEqual = function(a, b) {
|
|
if (a === b)
|
|
return true;
|
|
if (a == null || b == null)
|
|
return false;
|
|
if (a.length !== b.length)
|
|
return false;
|
|
for (let i = 0;i < a.length; ++i)
|
|
if (a[i] !== b[i])
|
|
return false;
|
|
return true;
|
|
};
|
|
var toAccessTier = function(tier2) {
|
|
if (tier2 === undefined)
|
|
return;
|
|
return tier2;
|
|
};
|
|
var ensureCpkIfSpecified = function(cpk, isHttps) {
|
|
if (cpk && !isHttps)
|
|
throw new RangeError("Customer-provided encryption key must be used over HTTPS.");
|
|
if (cpk && !cpk.encryptionAlgorithm)
|
|
cpk.encryptionAlgorithm = EncryptionAlgorithmAES25;
|
|
};
|
|
var rangeResponseFromModel = function(response) {
|
|
const pageRange = (response._response.parsedBody.pageRange || []).map((x) => ({
|
|
offset: x.start,
|
|
count: x.end - x.start
|
|
}));
|
|
const clearRange = (response._response.parsedBody.clearRange || []).map((x) => ({
|
|
offset: x.start,
|
|
count: x.end - x.start
|
|
}));
|
|
return Object.assign(Object.assign({}, response), {
|
|
pageRange,
|
|
clearRange,
|
|
_response: Object.assign(Object.assign({}, response._response), { parsedBody: {
|
|
pageRange,
|
|
clearRange
|
|
} })
|
|
});
|
|
};
|
|
var makeBlobBeginCopyFromURLPollOperation = function(state) {
|
|
return {
|
|
state: Object.assign({}, state),
|
|
cancel,
|
|
toString,
|
|
update
|
|
};
|
|
};
|
|
var rangeToString = function(iRange) {
|
|
if (iRange.offset < 0)
|
|
throw new RangeError(`Range.offset cannot be smaller than 0.`);
|
|
if (iRange.count && iRange.count <= 0)
|
|
throw new RangeError(`Range.count must be larger than 0. Leave it undefined if you want a range from offset to the end.`);
|
|
return iRange.count ? `bytes=${iRange.offset}-${iRange.offset + iRange.count - 1}` : `bytes=${iRange.offset}-`;
|
|
};
|
|
async function streamToBuffer(stream2, buffer, offset, end, encoding) {
|
|
let pos = 0;
|
|
const count = end - offset;
|
|
return new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => reject(new Error(`The operation cannot be completed in timeout.`)), REQUEST_TIMEOUT);
|
|
stream2.on("readable", () => {
|
|
if (pos >= count) {
|
|
clearTimeout(timeout);
|
|
resolve();
|
|
return;
|
|
}
|
|
let chunk = stream2.read();
|
|
if (!chunk)
|
|
return;
|
|
if (typeof chunk === "string")
|
|
chunk = Buffer.from(chunk, encoding);
|
|
const chunkLength = pos + chunk.length > count ? count - pos : chunk.length;
|
|
buffer.fill(chunk.slice(0, chunkLength), offset + pos, offset + pos + chunkLength);
|
|
pos += chunkLength;
|
|
});
|
|
stream2.on("end", () => {
|
|
clearTimeout(timeout);
|
|
if (pos < count)
|
|
reject(new Error(`Stream drains before getting enough data needed. Data read: ${pos}, data need: ${count}`));
|
|
resolve();
|
|
});
|
|
stream2.on("error", (msg) => {
|
|
clearTimeout(timeout);
|
|
reject(msg);
|
|
});
|
|
});
|
|
}
|
|
async function streamToBuffer2(stream2, buffer, encoding) {
|
|
let pos = 0;
|
|
const bufferSize = buffer.length;
|
|
return new Promise((resolve, reject) => {
|
|
stream2.on("readable", () => {
|
|
let chunk = stream2.read();
|
|
if (!chunk)
|
|
return;
|
|
if (typeof chunk === "string")
|
|
chunk = Buffer.from(chunk, encoding);
|
|
if (pos + chunk.length > bufferSize) {
|
|
reject(new Error(`Stream exceeds buffer size. Buffer size: ${bufferSize}`));
|
|
return;
|
|
}
|
|
buffer.fill(chunk, pos, pos + chunk.length);
|
|
pos += chunk.length;
|
|
});
|
|
stream2.on("end", () => {
|
|
resolve(pos);
|
|
});
|
|
stream2.on("error", reject);
|
|
});
|
|
}
|
|
async function readStreamToLocalFile(rs, file) {
|
|
return new Promise((resolve, reject) => {
|
|
const ws = fs__namespace.createWriteStream(file);
|
|
rs.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
ws.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
ws.on("close", resolve);
|
|
rs.pipe(ws);
|
|
});
|
|
}
|
|
async function getBodyAsText(batchResponse) {
|
|
let buffer = Buffer.alloc(BATCH_MAX_PAYLOAD_IN_BYTES);
|
|
const responseLength = await streamToBuffer2(batchResponse.readableStreamBody, buffer);
|
|
buffer = buffer.slice(0, responseLength);
|
|
return buffer.toString();
|
|
}
|
|
var utf8ByteLength = function(str) {
|
|
return Buffer.byteLength(str);
|
|
};
|
|
var generateAccountSASQueryParameters = function(accountSASSignatureValues, sharedKeyCredential) {
|
|
const version4 = accountSASSignatureValues.version ? accountSASSignatureValues.version : SERVICE_VERSION;
|
|
if (accountSASSignatureValues.permissions && accountSASSignatureValues.permissions.setImmutabilityPolicy && version4 < "2020-08-04")
|
|
throw RangeError("'version' must be >= '2020-08-04' when provided 'i' permission.");
|
|
if (accountSASSignatureValues.permissions && accountSASSignatureValues.permissions.deleteVersion && version4 < "2019-10-10")
|
|
throw RangeError("'version' must be >= '2019-10-10' when provided 'x' permission.");
|
|
if (accountSASSignatureValues.permissions && accountSASSignatureValues.permissions.permanentDelete && version4 < "2019-10-10")
|
|
throw RangeError("'version' must be >= '2019-10-10' when provided 'y' permission.");
|
|
if (accountSASSignatureValues.permissions && accountSASSignatureValues.permissions.tag && version4 < "2019-12-12")
|
|
throw RangeError("'version' must be >= '2019-12-12' when provided 't' permission.");
|
|
if (accountSASSignatureValues.permissions && accountSASSignatureValues.permissions.filter && version4 < "2019-12-12")
|
|
throw RangeError("'version' must be >= '2019-12-12' when provided 'f' permission.");
|
|
if (accountSASSignatureValues.encryptionScope && version4 < "2020-12-06")
|
|
throw RangeError("'version' must be >= '2020-12-06' when provided 'encryptionScope' in SAS.");
|
|
const parsedPermissions = AccountSASPermissions.parse(accountSASSignatureValues.permissions.toString());
|
|
const parsedServices = AccountSASServices.parse(accountSASSignatureValues.services).toString();
|
|
const parsedResourceTypes = AccountSASResourceTypes.parse(accountSASSignatureValues.resourceTypes).toString();
|
|
let stringToSign;
|
|
if (version4 >= "2020-12-06")
|
|
stringToSign = [
|
|
sharedKeyCredential.accountName,
|
|
parsedPermissions,
|
|
parsedServices,
|
|
parsedResourceTypes,
|
|
accountSASSignatureValues.startsOn ? truncatedISO8061Date(accountSASSignatureValues.startsOn, false) : "",
|
|
truncatedISO8061Date(accountSASSignatureValues.expiresOn, false),
|
|
accountSASSignatureValues.ipRange ? ipRangeToString(accountSASSignatureValues.ipRange) : "",
|
|
accountSASSignatureValues.protocol ? accountSASSignatureValues.protocol : "",
|
|
version4,
|
|
accountSASSignatureValues.encryptionScope ? accountSASSignatureValues.encryptionScope : "",
|
|
""
|
|
].join("\n");
|
|
else
|
|
stringToSign = [
|
|
sharedKeyCredential.accountName,
|
|
parsedPermissions,
|
|
parsedServices,
|
|
parsedResourceTypes,
|
|
accountSASSignatureValues.startsOn ? truncatedISO8061Date(accountSASSignatureValues.startsOn, false) : "",
|
|
truncatedISO8061Date(accountSASSignatureValues.expiresOn, false),
|
|
accountSASSignatureValues.ipRange ? ipRangeToString(accountSASSignatureValues.ipRange) : "",
|
|
accountSASSignatureValues.protocol ? accountSASSignatureValues.protocol : "",
|
|
version4,
|
|
""
|
|
].join("\n");
|
|
const signature = sharedKeyCredential.computeHMACSHA256(stringToSign);
|
|
return new SASQueryParameters(version4, signature, parsedPermissions.toString(), parsedServices, parsedResourceTypes, accountSASSignatureValues.protocol, accountSASSignatureValues.startsOn, accountSASSignatureValues.expiresOn, accountSASSignatureValues.ipRange, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, accountSASSignatureValues.encryptionScope);
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var coreHttp = require_dist6();
|
|
var tslib = (init_tslib_es6(), __toCommonJS(exports_tslib_es6));
|
|
var coreTracing = require_dist5();
|
|
var logger$1 = require_dist3();
|
|
var abortController = require_dist();
|
|
var os = __require("os");
|
|
var crypto7 = __require("crypto");
|
|
var stream = __require("stream");
|
|
require_dist7();
|
|
var coreLro = require_dist8();
|
|
var events = __require("events");
|
|
var fs = __require("fs");
|
|
var util = __require("util");
|
|
var coreHttp__namespace = _interopNamespace(coreHttp);
|
|
var os__namespace = _interopNamespace(os);
|
|
var fs__namespace = _interopNamespace(fs);
|
|
var util__namespace = _interopNamespace(util);
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobServiceStatistics = {
|
|
serializedName: "BlobServiceStatistics",
|
|
xmlName: "StorageServiceStats",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobServiceStatistics",
|
|
modelProperties: {
|
|
geoReplication: {
|
|
serializedName: "GeoReplication",
|
|
xmlName: "GeoReplication",
|
|
type: {
|
|
name: "Composite",
|
|
className: "GeoReplication"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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" } }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobName = {
|
|
serializedName: "BlobName",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobName",
|
|
modelProperties: {
|
|
encoded: {
|
|
serializedName: "Encoded",
|
|
xmlName: "Encoded",
|
|
xmlIsAttribute: true,
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
content: {
|
|
serializedName: "content",
|
|
xmlName: "content",
|
|
xmlIsMsText: true,
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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",
|
|
"Cold"
|
|
]
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobPrefix = {
|
|
serializedName: "BlobPrefix",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobPrefix",
|
|
modelProperties: {
|
|
name: {
|
|
serializedName: "Name",
|
|
xmlName: "Name",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobName"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
},
|
|
continuationToken: {
|
|
serializedName: "NextMarker",
|
|
xmlName: "NextMarker",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var QuerySerialization = {
|
|
serializedName: "QuerySerialization",
|
|
type: {
|
|
name: "Composite",
|
|
className: "QuerySerialization",
|
|
modelProperties: {
|
|
format: {
|
|
serializedName: "Format",
|
|
xmlName: "Format",
|
|
type: {
|
|
name: "Composite",
|
|
className: "QueryFormat"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var JsonTextConfiguration = {
|
|
serializedName: "JsonTextConfiguration",
|
|
xmlName: "JsonTextConfiguration",
|
|
type: {
|
|
name: "Composite",
|
|
className: "JsonTextConfiguration",
|
|
modelProperties: {
|
|
recordSeparator: {
|
|
serializedName: "RecordSeparator",
|
|
xmlName: "RecordSeparator",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceSetPropertiesExceptionHeaders = {
|
|
serializedName: "Service_setPropertiesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceSetPropertiesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceGetPropertiesExceptionHeaders = {
|
|
serializedName: "Service_getPropertiesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceGetPropertiesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceGetStatisticsExceptionHeaders = {
|
|
serializedName: "Service_getStatisticsExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceGetStatisticsExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceListContainersSegmentExceptionHeaders = {
|
|
serializedName: "Service_listContainersSegmentExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceListContainersSegmentExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceGetUserDelegationKeyExceptionHeaders = {
|
|
serializedName: "Service_getUserDelegationKeyExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceGetUserDelegationKeyExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceGetAccountInfoExceptionHeaders = {
|
|
serializedName: "Service_getAccountInfoExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceGetAccountInfoExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceSubmitBatchExceptionHeaders = {
|
|
serializedName: "Service_submitBatchExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceSubmitBatchExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ServiceFilterBlobsExceptionHeaders = {
|
|
serializedName: "Service_filterBlobsExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ServiceFilterBlobsExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerCreateExceptionHeaders = {
|
|
serializedName: "Container_createExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerCreateExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerGetPropertiesExceptionHeaders = {
|
|
serializedName: "Container_getPropertiesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerGetPropertiesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerDeleteExceptionHeaders = {
|
|
serializedName: "Container_deleteExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerDeleteExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerSetMetadataExceptionHeaders = {
|
|
serializedName: "Container_setMetadataExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerSetMetadataExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var 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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerGetAccessPolicyExceptionHeaders = {
|
|
serializedName: "Container_getAccessPolicyExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerGetAccessPolicyExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerSetAccessPolicyHeaders = {
|
|
serializedName: "Container_setAccessPolicyHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerSetAccessPolicyHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerSetAccessPolicyExceptionHeaders = {
|
|
serializedName: "Container_setAccessPolicyExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerSetAccessPolicyExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRestoreHeaders = {
|
|
serializedName: "Container_restoreHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRestoreHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRestoreExceptionHeaders = {
|
|
serializedName: "Container_restoreExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRestoreExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRenameHeaders = {
|
|
serializedName: "Container_renameHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRenameHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRenameExceptionHeaders = {
|
|
serializedName: "Container_renameExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRenameExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerSubmitBatchHeaders = {
|
|
serializedName: "Container_submitBatchHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerSubmitBatchHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerSubmitBatchExceptionHeaders = {
|
|
serializedName: "Container_submitBatchExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerSubmitBatchExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerFilterBlobsHeaders = {
|
|
serializedName: "Container_filterBlobsHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerFilterBlobsHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerFilterBlobsExceptionHeaders = {
|
|
serializedName: "Container_filterBlobsExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerFilterBlobsExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerAcquireLeaseHeaders = {
|
|
serializedName: "Container_acquireLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerAcquireLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerAcquireLeaseExceptionHeaders = {
|
|
serializedName: "Container_acquireLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerAcquireLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerReleaseLeaseHeaders = {
|
|
serializedName: "Container_releaseLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerReleaseLeaseHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerReleaseLeaseExceptionHeaders = {
|
|
serializedName: "Container_releaseLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerReleaseLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRenewLeaseHeaders = {
|
|
serializedName: "Container_renewLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRenewLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerRenewLeaseExceptionHeaders = {
|
|
serializedName: "Container_renewLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerRenewLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerBreakLeaseHeaders = {
|
|
serializedName: "Container_breakLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerBreakLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseTime: {
|
|
serializedName: "x-ms-lease-time",
|
|
xmlName: "x-ms-lease-time",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerBreakLeaseExceptionHeaders = {
|
|
serializedName: "Container_breakLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerBreakLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerChangeLeaseHeaders = {
|
|
serializedName: "Container_changeLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerChangeLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerChangeLeaseExceptionHeaders = {
|
|
serializedName: "Container_changeLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerChangeLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerListBlobFlatSegmentHeaders = {
|
|
serializedName: "Container_listBlobFlatSegmentHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerListBlobFlatSegmentHeaders",
|
|
modelProperties: {
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerListBlobFlatSegmentExceptionHeaders = {
|
|
serializedName: "Container_listBlobFlatSegmentExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerListBlobFlatSegmentExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerListBlobHierarchySegmentHeaders = {
|
|
serializedName: "Container_listBlobHierarchySegmentHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerListBlobHierarchySegmentHeaders",
|
|
modelProperties: {
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerListBlobHierarchySegmentExceptionHeaders = {
|
|
serializedName: "Container_listBlobHierarchySegmentExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerListBlobHierarchySegmentExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerGetAccountInfoHeaders = {
|
|
serializedName: "Container_getAccountInfoHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerGetAccountInfoHeaders",
|
|
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"
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ContainerGetAccountInfoExceptionHeaders = {
|
|
serializedName: "Container_getAccountInfoExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "ContainerGetAccountInfoExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDownloadHeaders = {
|
|
serializedName: "Blob_downloadHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDownloadHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
createdOn: {
|
|
serializedName: "x-ms-creation-time",
|
|
xmlName: "x-ms-creation-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
metadata: {
|
|
serializedName: "x-ms-meta",
|
|
xmlName: "x-ms-meta",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
},
|
|
headerCollectionPrefix: "x-ms-meta-"
|
|
},
|
|
objectReplicationPolicyId: {
|
|
serializedName: "x-ms-or-policy-id",
|
|
xmlName: "x-ms-or-policy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
objectReplicationRules: {
|
|
serializedName: "x-ms-or",
|
|
xmlName: "x-ms-or",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
},
|
|
headerCollectionPrefix: "x-ms-or-"
|
|
},
|
|
contentLength: {
|
|
serializedName: "content-length",
|
|
xmlName: "content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentRange: {
|
|
serializedName: "content-range",
|
|
xmlName: "content-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
contentEncoding: {
|
|
serializedName: "content-encoding",
|
|
xmlName: "content-encoding",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
cacheControl: {
|
|
serializedName: "cache-control",
|
|
xmlName: "cache-control",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentDisposition: {
|
|
serializedName: "content-disposition",
|
|
xmlName: "content-disposition",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentLanguage: {
|
|
serializedName: "content-language",
|
|
xmlName: "content-language",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
blobType: {
|
|
serializedName: "x-ms-blob-type",
|
|
xmlName: "x-ms-blob-type",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["BlockBlob", "PageBlob", "AppendBlob"]
|
|
}
|
|
},
|
|
copyCompletedOn: {
|
|
serializedName: "x-ms-copy-completion-time",
|
|
xmlName: "x-ms-copy-completion-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
copyStatusDescription: {
|
|
serializedName: "x-ms-copy-status-description",
|
|
xmlName: "x-ms-copy-status-description",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyProgress: {
|
|
serializedName: "x-ms-copy-progress",
|
|
xmlName: "x-ms-copy-progress",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copySource: {
|
|
serializedName: "x-ms-copy-source",
|
|
xmlName: "x-ms-copy-source",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
serializedName: "x-ms-copy-status",
|
|
xmlName: "x-ms-copy-status",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["pending", "success", "aborted", "failed"]
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
isCurrentVersion: {
|
|
serializedName: "x-ms-is-current-version",
|
|
xmlName: "x-ms-is-current-version",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
acceptRanges: {
|
|
serializedName: "accept-ranges",
|
|
xmlName: "accept-ranges",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
blobCommittedBlockCount: {
|
|
serializedName: "x-ms-blob-committed-block-count",
|
|
xmlName: "x-ms-blob-committed-block-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-server-encrypted",
|
|
xmlName: "x-ms-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobContentMD5: {
|
|
serializedName: "x-ms-blob-content-md5",
|
|
xmlName: "x-ms-blob-content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
tagCount: {
|
|
serializedName: "x-ms-tag-count",
|
|
xmlName: "x-ms-tag-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
isSealed: {
|
|
serializedName: "x-ms-blob-sealed",
|
|
xmlName: "x-ms-blob-sealed",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
lastAccessed: {
|
|
serializedName: "x-ms-last-access-time",
|
|
xmlName: "x-ms-last-access-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
immutabilityPolicyExpiresOn: {
|
|
serializedName: "x-ms-immutability-policy-until-date",
|
|
xmlName: "x-ms-immutability-policy-until-date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
immutabilityPolicyMode: {
|
|
serializedName: "x-ms-immutability-policy-mode",
|
|
xmlName: "x-ms-immutability-policy-mode",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["Mutable", "Unlocked", "Locked"]
|
|
}
|
|
},
|
|
legalHold: {
|
|
serializedName: "x-ms-legal-hold",
|
|
xmlName: "x-ms-legal-hold",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDownloadExceptionHeaders = {
|
|
serializedName: "Blob_downloadExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDownloadExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetPropertiesHeaders = {
|
|
serializedName: "Blob_getPropertiesHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetPropertiesHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
createdOn: {
|
|
serializedName: "x-ms-creation-time",
|
|
xmlName: "x-ms-creation-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
metadata: {
|
|
serializedName: "x-ms-meta",
|
|
xmlName: "x-ms-meta",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
},
|
|
headerCollectionPrefix: "x-ms-meta-"
|
|
},
|
|
objectReplicationPolicyId: {
|
|
serializedName: "x-ms-or-policy-id",
|
|
xmlName: "x-ms-or-policy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
objectReplicationRules: {
|
|
serializedName: "x-ms-or",
|
|
xmlName: "x-ms-or",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
},
|
|
headerCollectionPrefix: "x-ms-or-"
|
|
},
|
|
blobType: {
|
|
serializedName: "x-ms-blob-type",
|
|
xmlName: "x-ms-blob-type",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["BlockBlob", "PageBlob", "AppendBlob"]
|
|
}
|
|
},
|
|
copyCompletedOn: {
|
|
serializedName: "x-ms-copy-completion-time",
|
|
xmlName: "x-ms-copy-completion-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
copyStatusDescription: {
|
|
serializedName: "x-ms-copy-status-description",
|
|
xmlName: "x-ms-copy-status-description",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyProgress: {
|
|
serializedName: "x-ms-copy-progress",
|
|
xmlName: "x-ms-copy-progress",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copySource: {
|
|
serializedName: "x-ms-copy-source",
|
|
xmlName: "x-ms-copy-source",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
serializedName: "x-ms-copy-status",
|
|
xmlName: "x-ms-copy-status",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["pending", "success", "aborted", "failed"]
|
|
}
|
|
},
|
|
isIncrementalCopy: {
|
|
serializedName: "x-ms-incremental-copy",
|
|
xmlName: "x-ms-incremental-copy",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
destinationSnapshot: {
|
|
serializedName: "x-ms-copy-destination-snapshot",
|
|
xmlName: "x-ms-copy-destination-snapshot",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"]
|
|
}
|
|
},
|
|
contentLength: {
|
|
serializedName: "content-length",
|
|
xmlName: "content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
contentEncoding: {
|
|
serializedName: "content-encoding",
|
|
xmlName: "content-encoding",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentDisposition: {
|
|
serializedName: "content-disposition",
|
|
xmlName: "content-disposition",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentLanguage: {
|
|
serializedName: "content-language",
|
|
xmlName: "content-language",
|
|
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"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
acceptRanges: {
|
|
serializedName: "accept-ranges",
|
|
xmlName: "accept-ranges",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobCommittedBlockCount: {
|
|
serializedName: "x-ms-blob-committed-block-count",
|
|
xmlName: "x-ms-blob-committed-block-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-server-encrypted",
|
|
xmlName: "x-ms-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
accessTier: {
|
|
serializedName: "x-ms-access-tier",
|
|
xmlName: "x-ms-access-tier",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
accessTierInferred: {
|
|
serializedName: "x-ms-access-tier-inferred",
|
|
xmlName: "x-ms-access-tier-inferred",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
archiveStatus: {
|
|
serializedName: "x-ms-archive-status",
|
|
xmlName: "x-ms-archive-status",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
accessTierChangedOn: {
|
|
serializedName: "x-ms-access-tier-change-time",
|
|
xmlName: "x-ms-access-tier-change-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
isCurrentVersion: {
|
|
serializedName: "x-ms-is-current-version",
|
|
xmlName: "x-ms-is-current-version",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
tagCount: {
|
|
serializedName: "x-ms-tag-count",
|
|
xmlName: "x-ms-tag-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
expiresOn: {
|
|
serializedName: "x-ms-expiry-time",
|
|
xmlName: "x-ms-expiry-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isSealed: {
|
|
serializedName: "x-ms-blob-sealed",
|
|
xmlName: "x-ms-blob-sealed",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
rehydratePriority: {
|
|
serializedName: "x-ms-rehydrate-priority",
|
|
xmlName: "x-ms-rehydrate-priority",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["High", "Standard"]
|
|
}
|
|
},
|
|
lastAccessed: {
|
|
serializedName: "x-ms-last-access-time",
|
|
xmlName: "x-ms-last-access-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
immutabilityPolicyExpiresOn: {
|
|
serializedName: "x-ms-immutability-policy-until-date",
|
|
xmlName: "x-ms-immutability-policy-until-date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
immutabilityPolicyMode: {
|
|
serializedName: "x-ms-immutability-policy-mode",
|
|
xmlName: "x-ms-immutability-policy-mode",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["Mutable", "Unlocked", "Locked"]
|
|
}
|
|
},
|
|
legalHold: {
|
|
serializedName: "x-ms-legal-hold",
|
|
xmlName: "x-ms-legal-hold",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetPropertiesExceptionHeaders = {
|
|
serializedName: "Blob_getPropertiesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetPropertiesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDeleteHeaders = {
|
|
serializedName: "Blob_deleteHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDeleteHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDeleteExceptionHeaders = {
|
|
serializedName: "Blob_deleteExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDeleteExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobUndeleteHeaders = {
|
|
serializedName: "Blob_undeleteHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobUndeleteHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobUndeleteExceptionHeaders = {
|
|
serializedName: "Blob_undeleteExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobUndeleteExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetExpiryHeaders = {
|
|
serializedName: "Blob_setExpiryHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetExpiryHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetExpiryExceptionHeaders = {
|
|
serializedName: "Blob_setExpiryExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetExpiryExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetHttpHeadersHeaders = {
|
|
serializedName: "Blob_setHttpHeadersHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetHttpHeadersHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetHttpHeadersExceptionHeaders = {
|
|
serializedName: "Blob_setHttpHeadersExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetHttpHeadersExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetImmutabilityPolicyHeaders = {
|
|
serializedName: "Blob_setImmutabilityPolicyHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetImmutabilityPolicyHeaders",
|
|
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"
|
|
}
|
|
},
|
|
immutabilityPolicyExpiry: {
|
|
serializedName: "x-ms-immutability-policy-until-date",
|
|
xmlName: "x-ms-immutability-policy-until-date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
immutabilityPolicyMode: {
|
|
serializedName: "x-ms-immutability-policy-mode",
|
|
xmlName: "x-ms-immutability-policy-mode",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["Mutable", "Unlocked", "Locked"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetImmutabilityPolicyExceptionHeaders = {
|
|
serializedName: "Blob_setImmutabilityPolicyExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetImmutabilityPolicyExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDeleteImmutabilityPolicyHeaders = {
|
|
serializedName: "Blob_deleteImmutabilityPolicyHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDeleteImmutabilityPolicyHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobDeleteImmutabilityPolicyExceptionHeaders = {
|
|
serializedName: "Blob_deleteImmutabilityPolicyExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobDeleteImmutabilityPolicyExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetLegalHoldHeaders = {
|
|
serializedName: "Blob_setLegalHoldHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetLegalHoldHeaders",
|
|
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"
|
|
}
|
|
},
|
|
legalHold: {
|
|
serializedName: "x-ms-legal-hold",
|
|
xmlName: "x-ms-legal-hold",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetLegalHoldExceptionHeaders = {
|
|
serializedName: "Blob_setLegalHoldExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetLegalHoldExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetMetadataHeaders = {
|
|
serializedName: "Blob_setMetadataHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetMetadataHeaders",
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetMetadataExceptionHeaders = {
|
|
serializedName: "Blob_setMetadataExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetMetadataExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobAcquireLeaseHeaders = {
|
|
serializedName: "Blob_acquireLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobAcquireLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobAcquireLeaseExceptionHeaders = {
|
|
serializedName: "Blob_acquireLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobAcquireLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobReleaseLeaseHeaders = {
|
|
serializedName: "Blob_releaseLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobReleaseLeaseHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobReleaseLeaseExceptionHeaders = {
|
|
serializedName: "Blob_releaseLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobReleaseLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobRenewLeaseHeaders = {
|
|
serializedName: "Blob_renewLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobRenewLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobRenewLeaseExceptionHeaders = {
|
|
serializedName: "Blob_renewLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobRenewLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobChangeLeaseHeaders = {
|
|
serializedName: "Blob_changeLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobChangeLeaseHeaders",
|
|
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"
|
|
}
|
|
},
|
|
leaseId: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
version: {
|
|
serializedName: "x-ms-version",
|
|
xmlName: "x-ms-version",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobChangeLeaseExceptionHeaders = {
|
|
serializedName: "Blob_changeLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobChangeLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobBreakLeaseHeaders = {
|
|
serializedName: "Blob_breakLeaseHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobBreakLeaseHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
leaseTime: {
|
|
serializedName: "x-ms-lease-time",
|
|
xmlName: "x-ms-lease-time",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobBreakLeaseExceptionHeaders = {
|
|
serializedName: "Blob_breakLeaseExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobBreakLeaseExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobCreateSnapshotHeaders = {
|
|
serializedName: "Blob_createSnapshotHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobCreateSnapshotHeaders",
|
|
modelProperties: {
|
|
snapshot: {
|
|
serializedName: "x-ms-snapshot",
|
|
xmlName: "x-ms-snapshot",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobCreateSnapshotExceptionHeaders = {
|
|
serializedName: "Blob_createSnapshotExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobCreateSnapshotExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobStartCopyFromURLHeaders = {
|
|
serializedName: "Blob_startCopyFromURLHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobStartCopyFromURLHeaders",
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
serializedName: "x-ms-copy-status",
|
|
xmlName: "x-ms-copy-status",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["pending", "success", "aborted", "failed"]
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobStartCopyFromURLExceptionHeaders = {
|
|
serializedName: "Blob_startCopyFromURLExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobStartCopyFromURLExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobCopyFromURLHeaders = {
|
|
serializedName: "Blob_copyFromURLHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobCopyFromURLHeaders",
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
defaultValue: "success",
|
|
isConstant: true,
|
|
serializedName: "x-ms-copy-status",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobCopyFromURLExceptionHeaders = {
|
|
serializedName: "Blob_copyFromURLExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobCopyFromURLExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobAbortCopyFromURLHeaders = {
|
|
serializedName: "Blob_abortCopyFromURLHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobAbortCopyFromURLHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobAbortCopyFromURLExceptionHeaders = {
|
|
serializedName: "Blob_abortCopyFromURLExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobAbortCopyFromURLExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetTierHeaders = {
|
|
serializedName: "Blob_setTierHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetTierHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetTierExceptionHeaders = {
|
|
serializedName: "Blob_setTierExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetTierExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetAccountInfoHeaders = {
|
|
serializedName: "Blob_getAccountInfoHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetAccountInfoHeaders",
|
|
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"
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetAccountInfoExceptionHeaders = {
|
|
serializedName: "Blob_getAccountInfoExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetAccountInfoExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobQueryHeaders = {
|
|
serializedName: "Blob_queryHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobQueryHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
metadata: {
|
|
serializedName: "x-ms-meta",
|
|
xmlName: "x-ms-meta",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
}
|
|
},
|
|
contentLength: {
|
|
serializedName: "content-length",
|
|
xmlName: "content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentRange: {
|
|
serializedName: "content-range",
|
|
xmlName: "content-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
contentEncoding: {
|
|
serializedName: "content-encoding",
|
|
xmlName: "content-encoding",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
cacheControl: {
|
|
serializedName: "cache-control",
|
|
xmlName: "cache-control",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentDisposition: {
|
|
serializedName: "content-disposition",
|
|
xmlName: "content-disposition",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentLanguage: {
|
|
serializedName: "content-language",
|
|
xmlName: "content-language",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
blobType: {
|
|
serializedName: "x-ms-blob-type",
|
|
xmlName: "x-ms-blob-type",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["BlockBlob", "PageBlob", "AppendBlob"]
|
|
}
|
|
},
|
|
copyCompletionTime: {
|
|
serializedName: "x-ms-copy-completion-time",
|
|
xmlName: "x-ms-copy-completion-time",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
copyStatusDescription: {
|
|
serializedName: "x-ms-copy-status-description",
|
|
xmlName: "x-ms-copy-status-description",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyProgress: {
|
|
serializedName: "x-ms-copy-progress",
|
|
xmlName: "x-ms-copy-progress",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copySource: {
|
|
serializedName: "x-ms-copy-source",
|
|
xmlName: "x-ms-copy-source",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
serializedName: "x-ms-copy-status",
|
|
xmlName: "x-ms-copy-status",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["pending", "success", "aborted", "failed"]
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
acceptRanges: {
|
|
serializedName: "accept-ranges",
|
|
xmlName: "accept-ranges",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
blobCommittedBlockCount: {
|
|
serializedName: "x-ms-blob-committed-block-count",
|
|
xmlName: "x-ms-blob-committed-block-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-server-encrypted",
|
|
xmlName: "x-ms-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobContentMD5: {
|
|
serializedName: "x-ms-blob-content-md5",
|
|
xmlName: "x-ms-blob-content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobQueryExceptionHeaders = {
|
|
serializedName: "Blob_queryExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobQueryExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetTagsHeaders = {
|
|
serializedName: "Blob_getTagsHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetTagsHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobGetTagsExceptionHeaders = {
|
|
serializedName: "Blob_getTagsExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobGetTagsExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetTagsHeaders = {
|
|
serializedName: "Blob_setTagsHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetTagsHeaders",
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlobSetTagsExceptionHeaders = {
|
|
serializedName: "Blob_setTagsExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlobSetTagsExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobCreateHeaders = {
|
|
serializedName: "PageBlob_createHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobCreateHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobCreateExceptionHeaders = {
|
|
serializedName: "PageBlob_createExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobCreateExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUploadPagesHeaders = {
|
|
serializedName: "PageBlob_uploadPagesHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUploadPagesHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUploadPagesExceptionHeaders = {
|
|
serializedName: "PageBlob_uploadPagesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUploadPagesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobClearPagesHeaders = {
|
|
serializedName: "PageBlob_clearPagesHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobClearPagesHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobClearPagesExceptionHeaders = {
|
|
serializedName: "PageBlob_clearPagesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobClearPagesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUploadPagesFromURLHeaders = {
|
|
serializedName: "PageBlob_uploadPagesFromURLHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUploadPagesFromURLHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUploadPagesFromURLExceptionHeaders = {
|
|
serializedName: "PageBlob_uploadPagesFromURLExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUploadPagesFromURLExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobGetPageRangesHeaders = {
|
|
serializedName: "PageBlob_getPageRangesHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobGetPageRangesHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobContentLength: {
|
|
serializedName: "x-ms-blob-content-length",
|
|
xmlName: "x-ms-blob-content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobGetPageRangesExceptionHeaders = {
|
|
serializedName: "PageBlob_getPageRangesExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobGetPageRangesExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobGetPageRangesDiffHeaders = {
|
|
serializedName: "PageBlob_getPageRangesDiffHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobGetPageRangesDiffHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobContentLength: {
|
|
serializedName: "x-ms-blob-content-length",
|
|
xmlName: "x-ms-blob-content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobGetPageRangesDiffExceptionHeaders = {
|
|
serializedName: "PageBlob_getPageRangesDiffExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobGetPageRangesDiffExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobResizeHeaders = {
|
|
serializedName: "PageBlob_resizeHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobResizeHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobResizeExceptionHeaders = {
|
|
serializedName: "PageBlob_resizeExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobResizeExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUpdateSequenceNumberHeaders = {
|
|
serializedName: "PageBlob_updateSequenceNumberHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUpdateSequenceNumberHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
blobSequenceNumber: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobUpdateSequenceNumberExceptionHeaders = {
|
|
serializedName: "PageBlob_updateSequenceNumberExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobUpdateSequenceNumberExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobCopyIncrementalHeaders = {
|
|
serializedName: "PageBlob_copyIncrementalHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobCopyIncrementalHeaders",
|
|
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"
|
|
}
|
|
},
|
|
copyId: {
|
|
serializedName: "x-ms-copy-id",
|
|
xmlName: "x-ms-copy-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
copyStatus: {
|
|
serializedName: "x-ms-copy-status",
|
|
xmlName: "x-ms-copy-status",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["pending", "success", "aborted", "failed"]
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var PageBlobCopyIncrementalExceptionHeaders = {
|
|
serializedName: "PageBlob_copyIncrementalExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "PageBlobCopyIncrementalExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobCreateHeaders = {
|
|
serializedName: "AppendBlob_createHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobCreateHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobCreateExceptionHeaders = {
|
|
serializedName: "AppendBlob_createExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobCreateExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobAppendBlockHeaders = {
|
|
serializedName: "AppendBlob_appendBlockHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobAppendBlockHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
blobAppendOffset: {
|
|
serializedName: "x-ms-blob-append-offset",
|
|
xmlName: "x-ms-blob-append-offset",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobCommittedBlockCount: {
|
|
serializedName: "x-ms-blob-committed-block-count",
|
|
xmlName: "x-ms-blob-committed-block-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobAppendBlockExceptionHeaders = {
|
|
serializedName: "AppendBlob_appendBlockExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobAppendBlockExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobAppendBlockFromUrlHeaders = {
|
|
serializedName: "AppendBlob_appendBlockFromUrlHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobAppendBlockFromUrlHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
blobAppendOffset: {
|
|
serializedName: "x-ms-blob-append-offset",
|
|
xmlName: "x-ms-blob-append-offset",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobCommittedBlockCount: {
|
|
serializedName: "x-ms-blob-committed-block-count",
|
|
xmlName: "x-ms-blob-committed-block-count",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobAppendBlockFromUrlExceptionHeaders = {
|
|
serializedName: "AppendBlob_appendBlockFromUrlExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobAppendBlockFromUrlExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobSealHeaders = {
|
|
serializedName: "AppendBlob_sealHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobSealHeaders",
|
|
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"
|
|
}
|
|
},
|
|
isSealed: {
|
|
serializedName: "x-ms-blob-sealed",
|
|
xmlName: "x-ms-blob-sealed",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var AppendBlobSealExceptionHeaders = {
|
|
serializedName: "AppendBlob_sealExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "AppendBlobSealExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobUploadHeaders = {
|
|
serializedName: "BlockBlob_uploadHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobUploadHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobUploadExceptionHeaders = {
|
|
serializedName: "BlockBlob_uploadExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobUploadExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobPutBlobFromUrlHeaders = {
|
|
serializedName: "BlockBlob_putBlobFromUrlHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobPutBlobFromUrlHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobPutBlobFromUrlExceptionHeaders = {
|
|
serializedName: "BlockBlob_putBlobFromUrlExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobPutBlobFromUrlExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobStageBlockHeaders = {
|
|
serializedName: "BlockBlob_stageBlockHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobStageBlockHeaders",
|
|
modelProperties: {
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobStageBlockExceptionHeaders = {
|
|
serializedName: "BlockBlob_stageBlockExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobStageBlockExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobStageBlockFromURLHeaders = {
|
|
serializedName: "BlockBlob_stageBlockFromURLHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobStageBlockFromURLHeaders",
|
|
modelProperties: {
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobStageBlockFromURLExceptionHeaders = {
|
|
serializedName: "BlockBlob_stageBlockFromURLExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobStageBlockFromURLExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobCommitBlockListHeaders = {
|
|
serializedName: "BlockBlob_commitBlockListHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobCommitBlockListHeaders",
|
|
modelProperties: {
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
contentMD5: {
|
|
serializedName: "content-md5",
|
|
xmlName: "content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
xMsContentCrc64: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
},
|
|
versionId: {
|
|
serializedName: "x-ms-version-id",
|
|
xmlName: "x-ms-version-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
date: {
|
|
serializedName: "date",
|
|
xmlName: "date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
isServerEncrypted: {
|
|
serializedName: "x-ms-request-server-encrypted",
|
|
xmlName: "x-ms-request-server-encrypted",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
},
|
|
encryptionKeySha256: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
encryptionScope: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobCommitBlockListExceptionHeaders = {
|
|
serializedName: "BlockBlob_commitBlockListExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobCommitBlockListExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobGetBlockListHeaders = {
|
|
serializedName: "BlockBlob_getBlockListHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobGetBlockListHeaders",
|
|
modelProperties: {
|
|
lastModified: {
|
|
serializedName: "last-modified",
|
|
xmlName: "last-modified",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
},
|
|
etag: {
|
|
serializedName: "etag",
|
|
xmlName: "etag",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
contentType: {
|
|
serializedName: "content-type",
|
|
xmlName: "content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
blobContentLength: {
|
|
serializedName: "x-ms-blob-content-length",
|
|
xmlName: "x-ms-blob-content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
},
|
|
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"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var BlockBlobGetBlockListExceptionHeaders = {
|
|
serializedName: "BlockBlob_getBlockListExceptionHeaders",
|
|
type: {
|
|
name: "Composite",
|
|
className: "BlockBlobGetBlockListExceptionHeaders",
|
|
modelProperties: {
|
|
errorCode: {
|
|
serializedName: "x-ms-error-code",
|
|
xmlName: "x-ms-error-code",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var Mappers = Object.freeze({
|
|
__proto__: null,
|
|
BlobServiceProperties,
|
|
Logging,
|
|
RetentionPolicy,
|
|
Metrics,
|
|
CorsRule,
|
|
StaticWebsite,
|
|
StorageError,
|
|
BlobServiceStatistics,
|
|
GeoReplication,
|
|
ListContainersSegmentResponse,
|
|
ContainerItem,
|
|
ContainerProperties,
|
|
KeyInfo,
|
|
UserDelegationKey,
|
|
FilterBlobSegment,
|
|
FilterBlobItem,
|
|
BlobTags,
|
|
BlobTag,
|
|
SignedIdentifier,
|
|
AccessPolicy,
|
|
ListBlobsFlatSegmentResponse,
|
|
BlobFlatListSegment,
|
|
BlobItemInternal,
|
|
BlobName,
|
|
BlobPropertiesInternal,
|
|
ListBlobsHierarchySegmentResponse,
|
|
BlobHierarchyListSegment,
|
|
BlobPrefix,
|
|
BlockLookupList,
|
|
BlockList,
|
|
Block,
|
|
PageList,
|
|
PageRange,
|
|
ClearRange,
|
|
QueryRequest,
|
|
QuerySerialization,
|
|
QueryFormat,
|
|
DelimitedTextConfiguration,
|
|
JsonTextConfiguration,
|
|
ArrowConfiguration,
|
|
ArrowField,
|
|
ServiceSetPropertiesHeaders,
|
|
ServiceSetPropertiesExceptionHeaders,
|
|
ServiceGetPropertiesHeaders,
|
|
ServiceGetPropertiesExceptionHeaders,
|
|
ServiceGetStatisticsHeaders,
|
|
ServiceGetStatisticsExceptionHeaders,
|
|
ServiceListContainersSegmentHeaders,
|
|
ServiceListContainersSegmentExceptionHeaders,
|
|
ServiceGetUserDelegationKeyHeaders,
|
|
ServiceGetUserDelegationKeyExceptionHeaders,
|
|
ServiceGetAccountInfoHeaders,
|
|
ServiceGetAccountInfoExceptionHeaders,
|
|
ServiceSubmitBatchHeaders,
|
|
ServiceSubmitBatchExceptionHeaders,
|
|
ServiceFilterBlobsHeaders,
|
|
ServiceFilterBlobsExceptionHeaders,
|
|
ContainerCreateHeaders,
|
|
ContainerCreateExceptionHeaders,
|
|
ContainerGetPropertiesHeaders,
|
|
ContainerGetPropertiesExceptionHeaders,
|
|
ContainerDeleteHeaders,
|
|
ContainerDeleteExceptionHeaders,
|
|
ContainerSetMetadataHeaders,
|
|
ContainerSetMetadataExceptionHeaders,
|
|
ContainerGetAccessPolicyHeaders,
|
|
ContainerGetAccessPolicyExceptionHeaders,
|
|
ContainerSetAccessPolicyHeaders,
|
|
ContainerSetAccessPolicyExceptionHeaders,
|
|
ContainerRestoreHeaders,
|
|
ContainerRestoreExceptionHeaders,
|
|
ContainerRenameHeaders,
|
|
ContainerRenameExceptionHeaders,
|
|
ContainerSubmitBatchHeaders,
|
|
ContainerSubmitBatchExceptionHeaders,
|
|
ContainerFilterBlobsHeaders,
|
|
ContainerFilterBlobsExceptionHeaders,
|
|
ContainerAcquireLeaseHeaders,
|
|
ContainerAcquireLeaseExceptionHeaders,
|
|
ContainerReleaseLeaseHeaders,
|
|
ContainerReleaseLeaseExceptionHeaders,
|
|
ContainerRenewLeaseHeaders,
|
|
ContainerRenewLeaseExceptionHeaders,
|
|
ContainerBreakLeaseHeaders,
|
|
ContainerBreakLeaseExceptionHeaders,
|
|
ContainerChangeLeaseHeaders,
|
|
ContainerChangeLeaseExceptionHeaders,
|
|
ContainerListBlobFlatSegmentHeaders,
|
|
ContainerListBlobFlatSegmentExceptionHeaders,
|
|
ContainerListBlobHierarchySegmentHeaders,
|
|
ContainerListBlobHierarchySegmentExceptionHeaders,
|
|
ContainerGetAccountInfoHeaders,
|
|
ContainerGetAccountInfoExceptionHeaders,
|
|
BlobDownloadHeaders,
|
|
BlobDownloadExceptionHeaders,
|
|
BlobGetPropertiesHeaders,
|
|
BlobGetPropertiesExceptionHeaders,
|
|
BlobDeleteHeaders,
|
|
BlobDeleteExceptionHeaders,
|
|
BlobUndeleteHeaders,
|
|
BlobUndeleteExceptionHeaders,
|
|
BlobSetExpiryHeaders,
|
|
BlobSetExpiryExceptionHeaders,
|
|
BlobSetHttpHeadersHeaders,
|
|
BlobSetHttpHeadersExceptionHeaders,
|
|
BlobSetImmutabilityPolicyHeaders,
|
|
BlobSetImmutabilityPolicyExceptionHeaders,
|
|
BlobDeleteImmutabilityPolicyHeaders,
|
|
BlobDeleteImmutabilityPolicyExceptionHeaders,
|
|
BlobSetLegalHoldHeaders,
|
|
BlobSetLegalHoldExceptionHeaders,
|
|
BlobSetMetadataHeaders,
|
|
BlobSetMetadataExceptionHeaders,
|
|
BlobAcquireLeaseHeaders,
|
|
BlobAcquireLeaseExceptionHeaders,
|
|
BlobReleaseLeaseHeaders,
|
|
BlobReleaseLeaseExceptionHeaders,
|
|
BlobRenewLeaseHeaders,
|
|
BlobRenewLeaseExceptionHeaders,
|
|
BlobChangeLeaseHeaders,
|
|
BlobChangeLeaseExceptionHeaders,
|
|
BlobBreakLeaseHeaders,
|
|
BlobBreakLeaseExceptionHeaders,
|
|
BlobCreateSnapshotHeaders,
|
|
BlobCreateSnapshotExceptionHeaders,
|
|
BlobStartCopyFromURLHeaders,
|
|
BlobStartCopyFromURLExceptionHeaders,
|
|
BlobCopyFromURLHeaders,
|
|
BlobCopyFromURLExceptionHeaders,
|
|
BlobAbortCopyFromURLHeaders,
|
|
BlobAbortCopyFromURLExceptionHeaders,
|
|
BlobSetTierHeaders,
|
|
BlobSetTierExceptionHeaders,
|
|
BlobGetAccountInfoHeaders,
|
|
BlobGetAccountInfoExceptionHeaders,
|
|
BlobQueryHeaders,
|
|
BlobQueryExceptionHeaders,
|
|
BlobGetTagsHeaders,
|
|
BlobGetTagsExceptionHeaders,
|
|
BlobSetTagsHeaders,
|
|
BlobSetTagsExceptionHeaders,
|
|
PageBlobCreateHeaders,
|
|
PageBlobCreateExceptionHeaders,
|
|
PageBlobUploadPagesHeaders,
|
|
PageBlobUploadPagesExceptionHeaders,
|
|
PageBlobClearPagesHeaders,
|
|
PageBlobClearPagesExceptionHeaders,
|
|
PageBlobUploadPagesFromURLHeaders,
|
|
PageBlobUploadPagesFromURLExceptionHeaders,
|
|
PageBlobGetPageRangesHeaders,
|
|
PageBlobGetPageRangesExceptionHeaders,
|
|
PageBlobGetPageRangesDiffHeaders,
|
|
PageBlobGetPageRangesDiffExceptionHeaders,
|
|
PageBlobResizeHeaders,
|
|
PageBlobResizeExceptionHeaders,
|
|
PageBlobUpdateSequenceNumberHeaders,
|
|
PageBlobUpdateSequenceNumberExceptionHeaders,
|
|
PageBlobCopyIncrementalHeaders,
|
|
PageBlobCopyIncrementalExceptionHeaders,
|
|
AppendBlobCreateHeaders,
|
|
AppendBlobCreateExceptionHeaders,
|
|
AppendBlobAppendBlockHeaders,
|
|
AppendBlobAppendBlockExceptionHeaders,
|
|
AppendBlobAppendBlockFromUrlHeaders,
|
|
AppendBlobAppendBlockFromUrlExceptionHeaders,
|
|
AppendBlobSealHeaders,
|
|
AppendBlobSealExceptionHeaders,
|
|
BlockBlobUploadHeaders,
|
|
BlockBlobUploadExceptionHeaders,
|
|
BlockBlobPutBlobFromUrlHeaders,
|
|
BlockBlobPutBlobFromUrlExceptionHeaders,
|
|
BlockBlobStageBlockHeaders,
|
|
BlockBlobStageBlockExceptionHeaders,
|
|
BlockBlobStageBlockFromURLHeaders,
|
|
BlockBlobStageBlockFromURLExceptionHeaders,
|
|
BlockBlobCommitBlockListHeaders,
|
|
BlockBlobCommitBlockListExceptionHeaders,
|
|
BlockBlobGetBlockListHeaders,
|
|
BlockBlobGetBlockListExceptionHeaders
|
|
});
|
|
var contentType = {
|
|
parameterPath: ["options", "contentType"],
|
|
mapper: {
|
|
defaultValue: "application/xml",
|
|
isConstant: true,
|
|
serializedName: "Content-Type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobServiceProperties = {
|
|
parameterPath: "blobServiceProperties",
|
|
mapper: BlobServiceProperties
|
|
};
|
|
var accept = {
|
|
parameterPath: "accept",
|
|
mapper: {
|
|
defaultValue: "application/xml",
|
|
isConstant: true,
|
|
serializedName: "Accept",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var url = {
|
|
parameterPath: "url",
|
|
mapper: {
|
|
serializedName: "url",
|
|
required: true,
|
|
xmlName: "url",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
},
|
|
skipEncoding: true
|
|
};
|
|
var restype = {
|
|
parameterPath: "restype",
|
|
mapper: {
|
|
defaultValue: "service",
|
|
isConstant: true,
|
|
serializedName: "restype",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "properties",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var timeoutInSeconds = {
|
|
parameterPath: ["options", "timeoutInSeconds"],
|
|
mapper: {
|
|
constraints: {
|
|
InclusiveMinimum: 0
|
|
},
|
|
serializedName: "timeout",
|
|
xmlName: "timeout",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var version3 = {
|
|
parameterPath: "version",
|
|
mapper: {
|
|
defaultValue: "2022-11-02",
|
|
isConstant: true,
|
|
serializedName: "x-ms-version",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var requestId = {
|
|
parameterPath: ["options", "requestId"],
|
|
mapper: {
|
|
serializedName: "x-ms-client-request-id",
|
|
xmlName: "x-ms-client-request-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var accept1 = {
|
|
parameterPath: "accept",
|
|
mapper: {
|
|
defaultValue: "application/xml",
|
|
isConstant: true,
|
|
serializedName: "Accept",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp1 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "stats",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp2 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "list",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var prefix = {
|
|
parameterPath: ["options", "prefix"],
|
|
mapper: {
|
|
serializedName: "prefix",
|
|
xmlName: "prefix",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var marker = {
|
|
parameterPath: ["options", "marker"],
|
|
mapper: {
|
|
serializedName: "marker",
|
|
xmlName: "marker",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var maxPageSize = {
|
|
parameterPath: ["options", "maxPageSize"],
|
|
mapper: {
|
|
constraints: {
|
|
InclusiveMinimum: 1
|
|
},
|
|
serializedName: "maxresults",
|
|
xmlName: "maxresults",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var include = {
|
|
parameterPath: ["options", "include"],
|
|
mapper: {
|
|
serializedName: "include",
|
|
xmlName: "include",
|
|
xmlElementName: "ListContainersIncludeType",
|
|
type: {
|
|
name: "Sequence",
|
|
element: {
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["metadata", "deleted", "system"]
|
|
}
|
|
}
|
|
}
|
|
},
|
|
collectionFormat: coreHttp.QueryCollectionFormat.Csv
|
|
};
|
|
var keyInfo = {
|
|
parameterPath: "keyInfo",
|
|
mapper: KeyInfo
|
|
};
|
|
var comp3 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "userdelegationkey",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var restype1 = {
|
|
parameterPath: "restype",
|
|
mapper: {
|
|
defaultValue: "account",
|
|
isConstant: true,
|
|
serializedName: "restype",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var body = {
|
|
parameterPath: "body",
|
|
mapper: {
|
|
serializedName: "body",
|
|
required: true,
|
|
xmlName: "body",
|
|
type: {
|
|
name: "Stream"
|
|
}
|
|
}
|
|
};
|
|
var comp4 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "batch",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var contentLength = {
|
|
parameterPath: "contentLength",
|
|
mapper: {
|
|
serializedName: "Content-Length",
|
|
required: true,
|
|
xmlName: "Content-Length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var multipartContentType = {
|
|
parameterPath: "multipartContentType",
|
|
mapper: {
|
|
serializedName: "Content-Type",
|
|
required: true,
|
|
xmlName: "Content-Type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp5 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "blobs",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var where = {
|
|
parameterPath: ["options", "where"],
|
|
mapper: {
|
|
serializedName: "where",
|
|
xmlName: "where",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var restype2 = {
|
|
parameterPath: "restype",
|
|
mapper: {
|
|
defaultValue: "container",
|
|
isConstant: true,
|
|
serializedName: "restype",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var metadata = {
|
|
parameterPath: ["options", "metadata"],
|
|
mapper: {
|
|
serializedName: "x-ms-meta",
|
|
xmlName: "x-ms-meta",
|
|
type: {
|
|
name: "Dictionary",
|
|
value: { type: { name: "String" } }
|
|
},
|
|
headerCollectionPrefix: "x-ms-meta-"
|
|
}
|
|
};
|
|
var access = {
|
|
parameterPath: ["options", "access"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-public-access",
|
|
xmlName: "x-ms-blob-public-access",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["container", "blob"]
|
|
}
|
|
}
|
|
};
|
|
var defaultEncryptionScope = {
|
|
parameterPath: [
|
|
"options",
|
|
"containerEncryptionScope",
|
|
"defaultEncryptionScope"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-default-encryption-scope",
|
|
xmlName: "x-ms-default-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var preventEncryptionScopeOverride = {
|
|
parameterPath: [
|
|
"options",
|
|
"containerEncryptionScope",
|
|
"preventEncryptionScopeOverride"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-deny-encryption-scope-override",
|
|
xmlName: "x-ms-deny-encryption-scope-override",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var leaseId = {
|
|
parameterPath: ["options", "leaseAccessConditions", "leaseId"],
|
|
mapper: {
|
|
serializedName: "x-ms-lease-id",
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var ifModifiedSince = {
|
|
parameterPath: ["options", "modifiedAccessConditions", "ifModifiedSince"],
|
|
mapper: {
|
|
serializedName: "If-Modified-Since",
|
|
xmlName: "If-Modified-Since",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
};
|
|
var ifUnmodifiedSince = {
|
|
parameterPath: ["options", "modifiedAccessConditions", "ifUnmodifiedSince"],
|
|
mapper: {
|
|
serializedName: "If-Unmodified-Since",
|
|
xmlName: "If-Unmodified-Since",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
};
|
|
var comp6 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "metadata",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp7 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "acl",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var containerAcl = {
|
|
parameterPath: ["options", "containerAcl"],
|
|
mapper: {
|
|
serializedName: "containerAcl",
|
|
xmlName: "SignedIdentifiers",
|
|
xmlIsWrapped: true,
|
|
xmlElementName: "SignedIdentifier",
|
|
type: {
|
|
name: "Sequence",
|
|
element: {
|
|
type: {
|
|
name: "Composite",
|
|
className: "SignedIdentifier"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var comp8 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "undelete",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var deletedContainerName = {
|
|
parameterPath: ["options", "deletedContainerName"],
|
|
mapper: {
|
|
serializedName: "x-ms-deleted-container-name",
|
|
xmlName: "x-ms-deleted-container-name",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var deletedContainerVersion = {
|
|
parameterPath: ["options", "deletedContainerVersion"],
|
|
mapper: {
|
|
serializedName: "x-ms-deleted-container-version",
|
|
xmlName: "x-ms-deleted-container-version",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp9 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "rename",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceContainerName = {
|
|
parameterPath: "sourceContainerName",
|
|
mapper: {
|
|
serializedName: "x-ms-source-container-name",
|
|
required: true,
|
|
xmlName: "x-ms-source-container-name",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceLeaseId = {
|
|
parameterPath: ["options", "sourceLeaseId"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-lease-id",
|
|
xmlName: "x-ms-source-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp10 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "lease",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var action = {
|
|
parameterPath: "action",
|
|
mapper: {
|
|
defaultValue: "acquire",
|
|
isConstant: true,
|
|
serializedName: "x-ms-lease-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var duration = {
|
|
parameterPath: ["options", "duration"],
|
|
mapper: {
|
|
serializedName: "x-ms-lease-duration",
|
|
xmlName: "x-ms-lease-duration",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var proposedLeaseId = {
|
|
parameterPath: ["options", "proposedLeaseId"],
|
|
mapper: {
|
|
serializedName: "x-ms-proposed-lease-id",
|
|
xmlName: "x-ms-proposed-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var action1 = {
|
|
parameterPath: "action",
|
|
mapper: {
|
|
defaultValue: "release",
|
|
isConstant: true,
|
|
serializedName: "x-ms-lease-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var leaseId1 = {
|
|
parameterPath: "leaseId",
|
|
mapper: {
|
|
serializedName: "x-ms-lease-id",
|
|
required: true,
|
|
xmlName: "x-ms-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var action2 = {
|
|
parameterPath: "action",
|
|
mapper: {
|
|
defaultValue: "renew",
|
|
isConstant: true,
|
|
serializedName: "x-ms-lease-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var action3 = {
|
|
parameterPath: "action",
|
|
mapper: {
|
|
defaultValue: "break",
|
|
isConstant: true,
|
|
serializedName: "x-ms-lease-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var breakPeriod = {
|
|
parameterPath: ["options", "breakPeriod"],
|
|
mapper: {
|
|
serializedName: "x-ms-lease-break-period",
|
|
xmlName: "x-ms-lease-break-period",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var action4 = {
|
|
parameterPath: "action",
|
|
mapper: {
|
|
defaultValue: "change",
|
|
isConstant: true,
|
|
serializedName: "x-ms-lease-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var proposedLeaseId1 = {
|
|
parameterPath: "proposedLeaseId",
|
|
mapper: {
|
|
serializedName: "x-ms-proposed-lease-id",
|
|
required: true,
|
|
xmlName: "x-ms-proposed-lease-id",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var include1 = {
|
|
parameterPath: ["options", "include"],
|
|
mapper: {
|
|
serializedName: "include",
|
|
xmlName: "include",
|
|
xmlElementName: "ListBlobsIncludeItem",
|
|
type: {
|
|
name: "Sequence",
|
|
element: {
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: [
|
|
"copy",
|
|
"deleted",
|
|
"metadata",
|
|
"snapshots",
|
|
"uncommittedblobs",
|
|
"versions",
|
|
"tags",
|
|
"immutabilitypolicy",
|
|
"legalhold",
|
|
"deletedwithversions"
|
|
]
|
|
}
|
|
}
|
|
}
|
|
},
|
|
collectionFormat: coreHttp.QueryCollectionFormat.Csv
|
|
};
|
|
var delimiter = {
|
|
parameterPath: "delimiter",
|
|
mapper: {
|
|
serializedName: "delimiter",
|
|
required: true,
|
|
xmlName: "delimiter",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var snapshot = {
|
|
parameterPath: ["options", "snapshot"],
|
|
mapper: {
|
|
serializedName: "snapshot",
|
|
xmlName: "snapshot",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var versionId = {
|
|
parameterPath: ["options", "versionId"],
|
|
mapper: {
|
|
serializedName: "versionid",
|
|
xmlName: "versionid",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var range = {
|
|
parameterPath: ["options", "range"],
|
|
mapper: {
|
|
serializedName: "x-ms-range",
|
|
xmlName: "x-ms-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var rangeGetContentMD5 = {
|
|
parameterPath: ["options", "rangeGetContentMD5"],
|
|
mapper: {
|
|
serializedName: "x-ms-range-get-content-md5",
|
|
xmlName: "x-ms-range-get-content-md5",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var rangeGetContentCRC64 = {
|
|
parameterPath: ["options", "rangeGetContentCRC64"],
|
|
mapper: {
|
|
serializedName: "x-ms-range-get-content-crc64",
|
|
xmlName: "x-ms-range-get-content-crc64",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var encryptionKey = {
|
|
parameterPath: ["options", "cpkInfo", "encryptionKey"],
|
|
mapper: {
|
|
serializedName: "x-ms-encryption-key",
|
|
xmlName: "x-ms-encryption-key",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var encryptionKeySha256 = {
|
|
parameterPath: ["options", "cpkInfo", "encryptionKeySha256"],
|
|
mapper: {
|
|
serializedName: "x-ms-encryption-key-sha256",
|
|
xmlName: "x-ms-encryption-key-sha256",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var encryptionAlgorithm = {
|
|
parameterPath: ["options", "cpkInfo", "encryptionAlgorithm"],
|
|
mapper: {
|
|
serializedName: "x-ms-encryption-algorithm",
|
|
xmlName: "x-ms-encryption-algorithm",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var ifMatch = {
|
|
parameterPath: ["options", "modifiedAccessConditions", "ifMatch"],
|
|
mapper: {
|
|
serializedName: "If-Match",
|
|
xmlName: "If-Match",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var ifNoneMatch = {
|
|
parameterPath: ["options", "modifiedAccessConditions", "ifNoneMatch"],
|
|
mapper: {
|
|
serializedName: "If-None-Match",
|
|
xmlName: "If-None-Match",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var ifTags = {
|
|
parameterPath: ["options", "modifiedAccessConditions", "ifTags"],
|
|
mapper: {
|
|
serializedName: "x-ms-if-tags",
|
|
xmlName: "x-ms-if-tags",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var deleteSnapshots = {
|
|
parameterPath: ["options", "deleteSnapshots"],
|
|
mapper: {
|
|
serializedName: "x-ms-delete-snapshots",
|
|
xmlName: "x-ms-delete-snapshots",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["include", "only"]
|
|
}
|
|
}
|
|
};
|
|
var blobDeleteType = {
|
|
parameterPath: ["options", "blobDeleteType"],
|
|
mapper: {
|
|
serializedName: "deletetype",
|
|
xmlName: "deletetype",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp11 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "expiry",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var expiryOptions = {
|
|
parameterPath: "expiryOptions",
|
|
mapper: {
|
|
serializedName: "x-ms-expiry-option",
|
|
required: true,
|
|
xmlName: "x-ms-expiry-option",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var expiresOn = {
|
|
parameterPath: ["options", "expiresOn"],
|
|
mapper: {
|
|
serializedName: "x-ms-expiry-time",
|
|
xmlName: "x-ms-expiry-time",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobCacheControl = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobCacheControl"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-cache-control",
|
|
xmlName: "x-ms-blob-cache-control",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobContentType = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobContentType"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-type",
|
|
xmlName: "x-ms-blob-content-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobContentMD5 = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobContentMD5"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-md5",
|
|
xmlName: "x-ms-blob-content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
};
|
|
var blobContentEncoding = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobContentEncoding"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-encoding",
|
|
xmlName: "x-ms-blob-content-encoding",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobContentLanguage = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobContentLanguage"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-language",
|
|
xmlName: "x-ms-blob-content-language",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobContentDisposition = {
|
|
parameterPath: ["options", "blobHttpHeaders", "blobContentDisposition"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-disposition",
|
|
xmlName: "x-ms-blob-content-disposition",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp12 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "immutabilityPolicies",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var immutabilityPolicyExpiry = {
|
|
parameterPath: ["options", "immutabilityPolicyExpiry"],
|
|
mapper: {
|
|
serializedName: "x-ms-immutability-policy-until-date",
|
|
xmlName: "x-ms-immutability-policy-until-date",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
};
|
|
var immutabilityPolicyMode = {
|
|
parameterPath: ["options", "immutabilityPolicyMode"],
|
|
mapper: {
|
|
serializedName: "x-ms-immutability-policy-mode",
|
|
xmlName: "x-ms-immutability-policy-mode",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["Mutable", "Unlocked", "Locked"]
|
|
}
|
|
}
|
|
};
|
|
var comp13 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "legalhold",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var legalHold = {
|
|
parameterPath: "legalHold",
|
|
mapper: {
|
|
serializedName: "x-ms-legal-hold",
|
|
required: true,
|
|
xmlName: "x-ms-legal-hold",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var encryptionScope = {
|
|
parameterPath: ["options", "encryptionScope"],
|
|
mapper: {
|
|
serializedName: "x-ms-encryption-scope",
|
|
xmlName: "x-ms-encryption-scope",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp14 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "snapshot",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var tier = {
|
|
parameterPath: ["options", "tier"],
|
|
mapper: {
|
|
serializedName: "x-ms-access-tier",
|
|
xmlName: "x-ms-access-tier",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: [
|
|
"P4",
|
|
"P6",
|
|
"P10",
|
|
"P15",
|
|
"P20",
|
|
"P30",
|
|
"P40",
|
|
"P50",
|
|
"P60",
|
|
"P70",
|
|
"P80",
|
|
"Hot",
|
|
"Cool",
|
|
"Archive",
|
|
"Cold"
|
|
]
|
|
}
|
|
}
|
|
};
|
|
var rehydratePriority = {
|
|
parameterPath: ["options", "rehydratePriority"],
|
|
mapper: {
|
|
serializedName: "x-ms-rehydrate-priority",
|
|
xmlName: "x-ms-rehydrate-priority",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["High", "Standard"]
|
|
}
|
|
}
|
|
};
|
|
var sourceIfModifiedSince = {
|
|
parameterPath: [
|
|
"options",
|
|
"sourceModifiedAccessConditions",
|
|
"sourceIfModifiedSince"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-source-if-modified-since",
|
|
xmlName: "x-ms-source-if-modified-since",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
};
|
|
var sourceIfUnmodifiedSince = {
|
|
parameterPath: [
|
|
"options",
|
|
"sourceModifiedAccessConditions",
|
|
"sourceIfUnmodifiedSince"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-source-if-unmodified-since",
|
|
xmlName: "x-ms-source-if-unmodified-since",
|
|
type: {
|
|
name: "DateTimeRfc1123"
|
|
}
|
|
}
|
|
};
|
|
var sourceIfMatch = {
|
|
parameterPath: ["options", "sourceModifiedAccessConditions", "sourceIfMatch"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-if-match",
|
|
xmlName: "x-ms-source-if-match",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceIfNoneMatch = {
|
|
parameterPath: [
|
|
"options",
|
|
"sourceModifiedAccessConditions",
|
|
"sourceIfNoneMatch"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-source-if-none-match",
|
|
xmlName: "x-ms-source-if-none-match",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceIfTags = {
|
|
parameterPath: ["options", "sourceModifiedAccessConditions", "sourceIfTags"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-if-tags",
|
|
xmlName: "x-ms-source-if-tags",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var copySource = {
|
|
parameterPath: "copySource",
|
|
mapper: {
|
|
serializedName: "x-ms-copy-source",
|
|
required: true,
|
|
xmlName: "x-ms-copy-source",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobTagsString = {
|
|
parameterPath: ["options", "blobTagsString"],
|
|
mapper: {
|
|
serializedName: "x-ms-tags",
|
|
xmlName: "x-ms-tags",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sealBlob = {
|
|
parameterPath: ["options", "sealBlob"],
|
|
mapper: {
|
|
serializedName: "x-ms-seal-blob",
|
|
xmlName: "x-ms-seal-blob",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var legalHold1 = {
|
|
parameterPath: ["options", "legalHold"],
|
|
mapper: {
|
|
serializedName: "x-ms-legal-hold",
|
|
xmlName: "x-ms-legal-hold",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var xMsRequiresSync = {
|
|
parameterPath: "xMsRequiresSync",
|
|
mapper: {
|
|
defaultValue: "true",
|
|
isConstant: true,
|
|
serializedName: "x-ms-requires-sync",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceContentMD5 = {
|
|
parameterPath: ["options", "sourceContentMD5"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-content-md5",
|
|
xmlName: "x-ms-source-content-md5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
};
|
|
var copySourceAuthorization = {
|
|
parameterPath: ["options", "copySourceAuthorization"],
|
|
mapper: {
|
|
serializedName: "x-ms-copy-source-authorization",
|
|
xmlName: "x-ms-copy-source-authorization",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var copySourceTags = {
|
|
parameterPath: ["options", "copySourceTags"],
|
|
mapper: {
|
|
serializedName: "x-ms-copy-source-tag-option",
|
|
xmlName: "x-ms-copy-source-tag-option",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["REPLACE", "COPY"]
|
|
}
|
|
}
|
|
};
|
|
var comp15 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "copy",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var copyActionAbortConstant = {
|
|
parameterPath: "copyActionAbortConstant",
|
|
mapper: {
|
|
defaultValue: "abort",
|
|
isConstant: true,
|
|
serializedName: "x-ms-copy-action",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var copyId = {
|
|
parameterPath: "copyId",
|
|
mapper: {
|
|
serializedName: "copyid",
|
|
required: true,
|
|
xmlName: "copyid",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp16 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "tier",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var tier1 = {
|
|
parameterPath: "tier",
|
|
mapper: {
|
|
serializedName: "x-ms-access-tier",
|
|
required: true,
|
|
xmlName: "x-ms-access-tier",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: [
|
|
"P4",
|
|
"P6",
|
|
"P10",
|
|
"P15",
|
|
"P20",
|
|
"P30",
|
|
"P40",
|
|
"P50",
|
|
"P60",
|
|
"P70",
|
|
"P80",
|
|
"Hot",
|
|
"Cool",
|
|
"Archive",
|
|
"Cold"
|
|
]
|
|
}
|
|
}
|
|
};
|
|
var queryRequest = {
|
|
parameterPath: ["options", "queryRequest"],
|
|
mapper: QueryRequest
|
|
};
|
|
var comp17 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "query",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp18 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "tags",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var tags = {
|
|
parameterPath: ["options", "tags"],
|
|
mapper: BlobTags
|
|
};
|
|
var transactionalContentMD5 = {
|
|
parameterPath: ["options", "transactionalContentMD5"],
|
|
mapper: {
|
|
serializedName: "Content-MD5",
|
|
xmlName: "Content-MD5",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
};
|
|
var transactionalContentCrc64 = {
|
|
parameterPath: ["options", "transactionalContentCrc64"],
|
|
mapper: {
|
|
serializedName: "x-ms-content-crc64",
|
|
xmlName: "x-ms-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
};
|
|
var blobType = {
|
|
parameterPath: "blobType",
|
|
mapper: {
|
|
defaultValue: "PageBlob",
|
|
isConstant: true,
|
|
serializedName: "x-ms-blob-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobContentLength = {
|
|
parameterPath: "blobContentLength",
|
|
mapper: {
|
|
serializedName: "x-ms-blob-content-length",
|
|
required: true,
|
|
xmlName: "x-ms-blob-content-length",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var blobSequenceNumber = {
|
|
parameterPath: ["options", "blobSequenceNumber"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-sequence-number",
|
|
xmlName: "x-ms-blob-sequence-number",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var contentType1 = {
|
|
parameterPath: ["options", "contentType"],
|
|
mapper: {
|
|
defaultValue: "application/octet-stream",
|
|
isConstant: true,
|
|
serializedName: "Content-Type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var body1 = {
|
|
parameterPath: "body",
|
|
mapper: {
|
|
serializedName: "body",
|
|
required: true,
|
|
xmlName: "body",
|
|
type: {
|
|
name: "Stream"
|
|
}
|
|
}
|
|
};
|
|
var accept2 = {
|
|
parameterPath: "accept",
|
|
mapper: {
|
|
defaultValue: "application/xml",
|
|
isConstant: true,
|
|
serializedName: "Accept",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp19 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "page",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var pageWrite = {
|
|
parameterPath: "pageWrite",
|
|
mapper: {
|
|
defaultValue: "update",
|
|
isConstant: true,
|
|
serializedName: "x-ms-page-write",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var ifSequenceNumberLessThanOrEqualTo = {
|
|
parameterPath: [
|
|
"options",
|
|
"sequenceNumberAccessConditions",
|
|
"ifSequenceNumberLessThanOrEqualTo"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-if-sequence-number-le",
|
|
xmlName: "x-ms-if-sequence-number-le",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var ifSequenceNumberLessThan = {
|
|
parameterPath: [
|
|
"options",
|
|
"sequenceNumberAccessConditions",
|
|
"ifSequenceNumberLessThan"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-if-sequence-number-lt",
|
|
xmlName: "x-ms-if-sequence-number-lt",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var ifSequenceNumberEqualTo = {
|
|
parameterPath: [
|
|
"options",
|
|
"sequenceNumberAccessConditions",
|
|
"ifSequenceNumberEqualTo"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-if-sequence-number-eq",
|
|
xmlName: "x-ms-if-sequence-number-eq",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var pageWrite1 = {
|
|
parameterPath: "pageWrite",
|
|
mapper: {
|
|
defaultValue: "clear",
|
|
isConstant: true,
|
|
serializedName: "x-ms-page-write",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceUrl = {
|
|
parameterPath: "sourceUrl",
|
|
mapper: {
|
|
serializedName: "x-ms-copy-source",
|
|
required: true,
|
|
xmlName: "x-ms-copy-source",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceRange = {
|
|
parameterPath: "sourceRange",
|
|
mapper: {
|
|
serializedName: "x-ms-source-range",
|
|
required: true,
|
|
xmlName: "x-ms-source-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sourceContentCrc64 = {
|
|
parameterPath: ["options", "sourceContentCrc64"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-content-crc64",
|
|
xmlName: "x-ms-source-content-crc64",
|
|
type: {
|
|
name: "ByteArray"
|
|
}
|
|
}
|
|
};
|
|
var range1 = {
|
|
parameterPath: "range",
|
|
mapper: {
|
|
serializedName: "x-ms-range",
|
|
required: true,
|
|
xmlName: "x-ms-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp20 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "pagelist",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var prevsnapshot = {
|
|
parameterPath: ["options", "prevsnapshot"],
|
|
mapper: {
|
|
serializedName: "prevsnapshot",
|
|
xmlName: "prevsnapshot",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var prevSnapshotUrl = {
|
|
parameterPath: ["options", "prevSnapshotUrl"],
|
|
mapper: {
|
|
serializedName: "x-ms-previous-snapshot-url",
|
|
xmlName: "x-ms-previous-snapshot-url",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var sequenceNumberAction = {
|
|
parameterPath: "sequenceNumberAction",
|
|
mapper: {
|
|
serializedName: "x-ms-sequence-number-action",
|
|
required: true,
|
|
xmlName: "x-ms-sequence-number-action",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["max", "update", "increment"]
|
|
}
|
|
}
|
|
};
|
|
var comp21 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "incrementalcopy",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobType1 = {
|
|
parameterPath: "blobType",
|
|
mapper: {
|
|
defaultValue: "AppendBlob",
|
|
isConstant: true,
|
|
serializedName: "x-ms-blob-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp22 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "appendblock",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var maxSize = {
|
|
parameterPath: ["options", "appendPositionAccessConditions", "maxSize"],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-condition-maxsize",
|
|
xmlName: "x-ms-blob-condition-maxsize",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var appendPosition = {
|
|
parameterPath: [
|
|
"options",
|
|
"appendPositionAccessConditions",
|
|
"appendPosition"
|
|
],
|
|
mapper: {
|
|
serializedName: "x-ms-blob-condition-appendpos",
|
|
xmlName: "x-ms-blob-condition-appendpos",
|
|
type: {
|
|
name: "Number"
|
|
}
|
|
}
|
|
};
|
|
var sourceRange1 = {
|
|
parameterPath: ["options", "sourceRange"],
|
|
mapper: {
|
|
serializedName: "x-ms-source-range",
|
|
xmlName: "x-ms-source-range",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var comp23 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "seal",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blobType2 = {
|
|
parameterPath: "blobType",
|
|
mapper: {
|
|
defaultValue: "BlockBlob",
|
|
isConstant: true,
|
|
serializedName: "x-ms-blob-type",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var copySourceBlobProperties = {
|
|
parameterPath: ["options", "copySourceBlobProperties"],
|
|
mapper: {
|
|
serializedName: "x-ms-copy-source-blob-properties",
|
|
xmlName: "x-ms-copy-source-blob-properties",
|
|
type: {
|
|
name: "Boolean"
|
|
}
|
|
}
|
|
};
|
|
var comp24 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "block",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blockId = {
|
|
parameterPath: "blockId",
|
|
mapper: {
|
|
serializedName: "blockid",
|
|
required: true,
|
|
xmlName: "blockid",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var blocks = {
|
|
parameterPath: "blocks",
|
|
mapper: BlockLookupList
|
|
};
|
|
var comp25 = {
|
|
parameterPath: "comp",
|
|
mapper: {
|
|
defaultValue: "blocklist",
|
|
isConstant: true,
|
|
serializedName: "comp",
|
|
type: {
|
|
name: "String"
|
|
}
|
|
}
|
|
};
|
|
var listType = {
|
|
parameterPath: "listType",
|
|
mapper: {
|
|
defaultValue: "committed",
|
|
serializedName: "blocklisttype",
|
|
required: true,
|
|
xmlName: "blocklisttype",
|
|
type: {
|
|
name: "Enum",
|
|
allowedValues: ["committed", "uncommitted", "all"]
|
|
}
|
|
}
|
|
};
|
|
|
|
class Service {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
setProperties(blobServiceProperties2, options) {
|
|
const operationArguments = {
|
|
blobServiceProperties: blobServiceProperties2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setPropertiesOperationSpec);
|
|
}
|
|
getProperties(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getPropertiesOperationSpec$2);
|
|
}
|
|
getStatistics(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getStatisticsOperationSpec);
|
|
}
|
|
listContainersSegment(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, listContainersSegmentOperationSpec);
|
|
}
|
|
getUserDelegationKey(keyInfo2, options) {
|
|
const operationArguments = {
|
|
keyInfo: keyInfo2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getUserDelegationKeyOperationSpec);
|
|
}
|
|
getAccountInfo(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getAccountInfoOperationSpec$2);
|
|
}
|
|
submitBatch(contentLength2, multipartContentType2, body2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
multipartContentType: multipartContentType2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, submitBatchOperationSpec$1);
|
|
}
|
|
filterBlobs(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, filterBlobsOperationSpec$1);
|
|
}
|
|
}
|
|
var xmlSerializer$5 = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var setPropertiesOperationSpec = {
|
|
path: "/",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: ServiceSetPropertiesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceSetPropertiesExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: blobServiceProperties,
|
|
queryParameters: [
|
|
restype,
|
|
comp,
|
|
timeoutInSeconds
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var getPropertiesOperationSpec$2 = {
|
|
path: "/",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: BlobServiceProperties,
|
|
headersMapper: ServiceGetPropertiesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceGetPropertiesExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
restype,
|
|
comp,
|
|
timeoutInSeconds
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var getStatisticsOperationSpec = {
|
|
path: "/",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: BlobServiceStatistics,
|
|
headersMapper: ServiceGetStatisticsHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceGetStatisticsExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
restype,
|
|
timeoutInSeconds,
|
|
comp1
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var listContainersSegmentOperationSpec = {
|
|
path: "/",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: ListContainersSegmentResponse,
|
|
headersMapper: ServiceListContainersSegmentHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceListContainersSegmentExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp2,
|
|
prefix,
|
|
marker,
|
|
maxPageSize,
|
|
include
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var getUserDelegationKeyOperationSpec = {
|
|
path: "/",
|
|
httpMethod: "POST",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: UserDelegationKey,
|
|
headersMapper: ServiceGetUserDelegationKeyHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceGetUserDelegationKeyExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: keyInfo,
|
|
queryParameters: [
|
|
restype,
|
|
timeoutInSeconds,
|
|
comp3
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var getAccountInfoOperationSpec$2 = {
|
|
path: "/",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ServiceGetAccountInfoHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceGetAccountInfoExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, restype1],
|
|
urlParameters: [url],
|
|
headerParameters: [version3, accept1],
|
|
isXML: true,
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var submitBatchOperationSpec$1 = {
|
|
path: "/",
|
|
httpMethod: "POST",
|
|
responses: {
|
|
202: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: ServiceSubmitBatchHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceSubmitBatchExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body,
|
|
queryParameters: [timeoutInSeconds, comp4],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
multipartContentType
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$5
|
|
};
|
|
var filterBlobsOperationSpec$1 = {
|
|
path: "/",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: FilterBlobSegment,
|
|
headersMapper: ServiceFilterBlobsHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ServiceFilterBlobsExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
marker,
|
|
maxPageSize,
|
|
comp5,
|
|
where
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$5
|
|
};
|
|
|
|
class Container {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
create(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, createOperationSpec$2);
|
|
}
|
|
getProperties(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getPropertiesOperationSpec$1);
|
|
}
|
|
delete(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, deleteOperationSpec$1);
|
|
}
|
|
setMetadata(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setMetadataOperationSpec$1);
|
|
}
|
|
getAccessPolicy(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getAccessPolicyOperationSpec);
|
|
}
|
|
setAccessPolicy(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setAccessPolicyOperationSpec);
|
|
}
|
|
restore(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, restoreOperationSpec);
|
|
}
|
|
rename(sourceContainerName2, options) {
|
|
const operationArguments = {
|
|
sourceContainerName: sourceContainerName2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, renameOperationSpec);
|
|
}
|
|
submitBatch(contentLength2, multipartContentType2, body2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
multipartContentType: multipartContentType2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, submitBatchOperationSpec);
|
|
}
|
|
filterBlobs(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, filterBlobsOperationSpec);
|
|
}
|
|
acquireLease(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, acquireLeaseOperationSpec$1);
|
|
}
|
|
releaseLease(leaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, releaseLeaseOperationSpec$1);
|
|
}
|
|
renewLease(leaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, renewLeaseOperationSpec$1);
|
|
}
|
|
breakLease(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, breakLeaseOperationSpec$1);
|
|
}
|
|
changeLease(leaseId2, proposedLeaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
proposedLeaseId: proposedLeaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, changeLeaseOperationSpec$1);
|
|
}
|
|
listBlobFlatSegment(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, listBlobFlatSegmentOperationSpec);
|
|
}
|
|
listBlobHierarchySegment(delimiter2, options) {
|
|
const operationArguments = {
|
|
delimiter: delimiter2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, listBlobHierarchySegmentOperationSpec);
|
|
}
|
|
getAccountInfo(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getAccountInfoOperationSpec$1);
|
|
}
|
|
}
|
|
var xmlSerializer$4 = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var createOperationSpec$2 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: ContainerCreateHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerCreateExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, restype2],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
access,
|
|
defaultEncryptionScope,
|
|
preventEncryptionScopeOverride
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var getPropertiesOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerGetPropertiesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerGetPropertiesExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, restype2],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var deleteOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "DELETE",
|
|
responses: {
|
|
202: {
|
|
headersMapper: ContainerDeleteHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerDeleteExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, restype2],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var setMetadataOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerSetMetadataHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerSetMetadataExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp6
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var getAccessPolicyOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: {
|
|
type: {
|
|
name: "Sequence",
|
|
element: {
|
|
type: { name: "Composite", className: "SignedIdentifier" }
|
|
}
|
|
},
|
|
serializedName: "SignedIdentifiers",
|
|
xmlName: "SignedIdentifiers",
|
|
xmlIsWrapped: true,
|
|
xmlElementName: "SignedIdentifier"
|
|
},
|
|
headersMapper: ContainerGetAccessPolicyHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerGetAccessPolicyExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp7
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var setAccessPolicyOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerSetAccessPolicyHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerSetAccessPolicyExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: containerAcl,
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp7
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
access,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var restoreOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: ContainerRestoreHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerRestoreExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp8
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
deletedContainerName,
|
|
deletedContainerVersion
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var renameOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerRenameHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerRenameExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp9
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
sourceContainerName,
|
|
sourceLeaseId
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var submitBatchOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "POST",
|
|
responses: {
|
|
202: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: ContainerSubmitBatchHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerSubmitBatchExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body,
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp4,
|
|
restype2
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
multipartContentType
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var filterBlobsOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: FilterBlobSegment,
|
|
headersMapper: ContainerFilterBlobsHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerFilterBlobsExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
marker,
|
|
maxPageSize,
|
|
comp5,
|
|
where,
|
|
restype2
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var acquireLeaseOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: ContainerAcquireLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerAcquireLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp10
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action,
|
|
duration,
|
|
proposedLeaseId
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var releaseLeaseOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerReleaseLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerReleaseLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp10
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action1,
|
|
leaseId1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var renewLeaseOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerRenewLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerRenewLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp10
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
leaseId1,
|
|
action2
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var breakLeaseOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: ContainerBreakLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerBreakLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp10
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action3,
|
|
breakPeriod
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var changeLeaseOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerChangeLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerChangeLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
restype2,
|
|
comp10
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
leaseId1,
|
|
action4,
|
|
proposedLeaseId1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var listBlobFlatSegmentOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: ListBlobsFlatSegmentResponse,
|
|
headersMapper: ContainerListBlobFlatSegmentHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerListBlobFlatSegmentExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp2,
|
|
prefix,
|
|
marker,
|
|
maxPageSize,
|
|
restype2,
|
|
include1
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var listBlobHierarchySegmentOperationSpec = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: ListBlobsHierarchySegmentResponse,
|
|
headersMapper: ContainerListBlobHierarchySegmentHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerListBlobHierarchySegmentExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp2,
|
|
prefix,
|
|
marker,
|
|
maxPageSize,
|
|
restype2,
|
|
include1,
|
|
delimiter
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
var getAccountInfoOperationSpec$1 = {
|
|
path: "/{containerName}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
headersMapper: ContainerGetAccountInfoHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: ContainerGetAccountInfoExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, restype1],
|
|
urlParameters: [url],
|
|
headerParameters: [version3, accept1],
|
|
isXML: true,
|
|
serializer: xmlSerializer$4
|
|
};
|
|
|
|
class Blob$1 {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
download(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, downloadOperationSpec);
|
|
}
|
|
getProperties(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getPropertiesOperationSpec);
|
|
}
|
|
delete(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, deleteOperationSpec);
|
|
}
|
|
undelete(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, undeleteOperationSpec);
|
|
}
|
|
setExpiry(expiryOptions2, options) {
|
|
const operationArguments = {
|
|
expiryOptions: expiryOptions2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setExpiryOperationSpec);
|
|
}
|
|
setHttpHeaders(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setHttpHeadersOperationSpec);
|
|
}
|
|
setImmutabilityPolicy(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setImmutabilityPolicyOperationSpec);
|
|
}
|
|
deleteImmutabilityPolicy(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, deleteImmutabilityPolicyOperationSpec);
|
|
}
|
|
setLegalHold(legalHold2, options) {
|
|
const operationArguments = {
|
|
legalHold: legalHold2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setLegalHoldOperationSpec);
|
|
}
|
|
setMetadata(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setMetadataOperationSpec);
|
|
}
|
|
acquireLease(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, acquireLeaseOperationSpec);
|
|
}
|
|
releaseLease(leaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, releaseLeaseOperationSpec);
|
|
}
|
|
renewLease(leaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, renewLeaseOperationSpec);
|
|
}
|
|
changeLease(leaseId2, proposedLeaseId2, options) {
|
|
const operationArguments = {
|
|
leaseId: leaseId2,
|
|
proposedLeaseId: proposedLeaseId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, changeLeaseOperationSpec);
|
|
}
|
|
breakLease(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, breakLeaseOperationSpec);
|
|
}
|
|
createSnapshot(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, createSnapshotOperationSpec);
|
|
}
|
|
startCopyFromURL(copySource2, options) {
|
|
const operationArguments = {
|
|
copySource: copySource2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, startCopyFromURLOperationSpec);
|
|
}
|
|
copyFromURL(copySource2, options) {
|
|
const operationArguments = {
|
|
copySource: copySource2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, copyFromURLOperationSpec);
|
|
}
|
|
abortCopyFromURL(copyId2, options) {
|
|
const operationArguments = {
|
|
copyId: copyId2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, abortCopyFromURLOperationSpec);
|
|
}
|
|
setTier(tier2, options) {
|
|
const operationArguments = {
|
|
tier: tier2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setTierOperationSpec);
|
|
}
|
|
getAccountInfo(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getAccountInfoOperationSpec);
|
|
}
|
|
query(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, queryOperationSpec);
|
|
}
|
|
getTags(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getTagsOperationSpec);
|
|
}
|
|
setTags(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, setTagsOperationSpec);
|
|
}
|
|
}
|
|
var xmlSerializer$3 = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var downloadOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: BlobDownloadHeaders
|
|
},
|
|
206: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: BlobDownloadHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobDownloadExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
versionId
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
range,
|
|
rangeGetContentMD5,
|
|
rangeGetContentCRC64,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var getPropertiesOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "HEAD",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobGetPropertiesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobGetPropertiesExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
versionId
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var deleteOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "DELETE",
|
|
responses: {
|
|
202: {
|
|
headersMapper: BlobDeleteHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobDeleteExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
versionId,
|
|
blobDeleteType
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
deleteSnapshots
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var undeleteOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobUndeleteHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobUndeleteExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp8],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setExpiryOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetExpiryHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetExpiryExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp11],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
expiryOptions,
|
|
expiresOn
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setHttpHeadersOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetHttpHeadersHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetHttpHeadersExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setImmutabilityPolicyOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetImmutabilityPolicyHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetImmutabilityPolicyExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp12],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifUnmodifiedSince,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var deleteImmutabilityPolicyOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "DELETE",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobDeleteImmutabilityPolicyHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobDeleteImmutabilityPolicyExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp12],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setLegalHoldOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetLegalHoldHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetLegalHoldExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp13],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
legalHold
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setMetadataOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetMetadataHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetMetadataExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp6],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var acquireLeaseOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlobAcquireLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobAcquireLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp10],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action,
|
|
duration,
|
|
proposedLeaseId,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var releaseLeaseOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobReleaseLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobReleaseLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp10],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action1,
|
|
leaseId1,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var renewLeaseOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobRenewLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobRenewLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp10],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
leaseId1,
|
|
action2,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var changeLeaseOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobChangeLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobChangeLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp10],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
leaseId1,
|
|
action4,
|
|
proposedLeaseId1,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var breakLeaseOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: BlobBreakLeaseHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobBreakLeaseExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp10],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
action3,
|
|
breakPeriod,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var createSnapshotOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlobCreateSnapshotHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobCreateSnapshotExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp14],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var startCopyFromURLOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: BlobStartCopyFromURLHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobStartCopyFromURLExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
tier,
|
|
rehydratePriority,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
sourceIfTags,
|
|
copySource,
|
|
blobTagsString,
|
|
sealBlob,
|
|
legalHold1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var copyFromURLOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: BlobCopyFromURLHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobCopyFromURLExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
encryptionScope,
|
|
tier,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
copySource,
|
|
blobTagsString,
|
|
legalHold1,
|
|
xMsRequiresSync,
|
|
sourceContentMD5,
|
|
copySourceAuthorization,
|
|
copySourceTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var abortCopyFromURLOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
204: {
|
|
headersMapper: BlobAbortCopyFromURLHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobAbortCopyFromURLExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp15,
|
|
copyId
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
copyActionAbortConstant
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setTierOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobSetTierHeaders
|
|
},
|
|
202: {
|
|
headersMapper: BlobSetTierHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetTierExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
versionId,
|
|
comp16
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifTags,
|
|
rehydratePriority,
|
|
tier1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var getAccountInfoOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
headersMapper: BlobGetAccountInfoHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobGetAccountInfoExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, restype1],
|
|
urlParameters: [url],
|
|
headerParameters: [version3, accept1],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var queryOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "POST",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: BlobQueryHeaders
|
|
},
|
|
206: {
|
|
bodyMapper: {
|
|
type: { name: "Stream" },
|
|
serializedName: "parsedResponse"
|
|
},
|
|
headersMapper: BlobQueryHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobQueryExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: queryRequest,
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
comp17
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var getTagsOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: BlobTags,
|
|
headersMapper: BlobGetTagsHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobGetTagsExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
versionId,
|
|
comp18
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$3
|
|
};
|
|
var setTagsOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
204: {
|
|
headersMapper: BlobSetTagsHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlobSetTagsExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: tags,
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
versionId,
|
|
comp18
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
leaseId,
|
|
ifTags,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer$3
|
|
};
|
|
|
|
class PageBlob {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
create(contentLength2, blobContentLength2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
blobContentLength: blobContentLength2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, createOperationSpec$1);
|
|
}
|
|
uploadPages(contentLength2, body2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, uploadPagesOperationSpec);
|
|
}
|
|
clearPages(contentLength2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, clearPagesOperationSpec);
|
|
}
|
|
uploadPagesFromURL(sourceUrl2, sourceRange2, contentLength2, range2, options) {
|
|
const operationArguments = {
|
|
sourceUrl: sourceUrl2,
|
|
sourceRange: sourceRange2,
|
|
contentLength: contentLength2,
|
|
range: range2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, uploadPagesFromURLOperationSpec);
|
|
}
|
|
getPageRanges(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getPageRangesOperationSpec);
|
|
}
|
|
getPageRangesDiff(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getPageRangesDiffOperationSpec);
|
|
}
|
|
resize(blobContentLength2, options) {
|
|
const operationArguments = {
|
|
blobContentLength: blobContentLength2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, resizeOperationSpec);
|
|
}
|
|
updateSequenceNumber(sequenceNumberAction2, options) {
|
|
const operationArguments = {
|
|
sequenceNumberAction: sequenceNumberAction2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, updateSequenceNumberOperationSpec);
|
|
}
|
|
copyIncremental(copySource2, options) {
|
|
const operationArguments = {
|
|
copySource: copySource2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, copyIncrementalOperationSpec);
|
|
}
|
|
}
|
|
var xmlSerializer$2 = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var serializer$2 = new coreHttp__namespace.Serializer(Mappers, false);
|
|
var createOperationSpec$1 = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: PageBlobCreateHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobCreateExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
encryptionScope,
|
|
tier,
|
|
blobTagsString,
|
|
legalHold1,
|
|
blobType,
|
|
blobContentLength,
|
|
blobSequenceNumber
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var uploadPagesOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: PageBlobUploadPagesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobUploadPagesExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body1,
|
|
queryParameters: [timeoutInSeconds, comp19],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
range,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64,
|
|
contentType1,
|
|
accept2,
|
|
pageWrite,
|
|
ifSequenceNumberLessThanOrEqualTo,
|
|
ifSequenceNumberLessThan,
|
|
ifSequenceNumberEqualTo
|
|
],
|
|
mediaType: "binary",
|
|
serializer: serializer$2
|
|
};
|
|
var clearPagesOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: PageBlobClearPagesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobClearPagesExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp19],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
range,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
ifSequenceNumberLessThanOrEqualTo,
|
|
ifSequenceNumberLessThan,
|
|
ifSequenceNumberEqualTo,
|
|
pageWrite1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var uploadPagesFromURLOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: PageBlobUploadPagesFromURLHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobUploadPagesFromURLExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp19],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
sourceContentMD5,
|
|
copySourceAuthorization,
|
|
pageWrite,
|
|
ifSequenceNumberLessThanOrEqualTo,
|
|
ifSequenceNumberLessThan,
|
|
ifSequenceNumberEqualTo,
|
|
sourceUrl,
|
|
sourceRange,
|
|
sourceContentCrc64,
|
|
range1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var getPageRangesOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: PageList,
|
|
headersMapper: PageBlobGetPageRangesHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobGetPageRangesExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
marker,
|
|
maxPageSize,
|
|
snapshot,
|
|
comp20
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
range,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var getPageRangesDiffOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: PageList,
|
|
headersMapper: PageBlobGetPageRangesDiffHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobGetPageRangesDiffExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
marker,
|
|
maxPageSize,
|
|
snapshot,
|
|
comp20,
|
|
prevsnapshot
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
range,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
prevSnapshotUrl
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var resizeOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: PageBlobResizeHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobResizeExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
blobContentLength
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var updateSequenceNumberOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: PageBlobUpdateSequenceNumberHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobUpdateSequenceNumberExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [comp, timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobSequenceNumber,
|
|
sequenceNumberAction
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
var copyIncrementalOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
202: {
|
|
headersMapper: PageBlobCopyIncrementalHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: PageBlobCopyIncrementalExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp21],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
copySource
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$2
|
|
};
|
|
|
|
class AppendBlob {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
create(contentLength2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, createOperationSpec);
|
|
}
|
|
appendBlock(contentLength2, body2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, appendBlockOperationSpec);
|
|
}
|
|
appendBlockFromUrl(sourceUrl2, contentLength2, options) {
|
|
const operationArguments = {
|
|
sourceUrl: sourceUrl2,
|
|
contentLength: contentLength2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, appendBlockFromUrlOperationSpec);
|
|
}
|
|
seal(options) {
|
|
const operationArguments = {
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, sealOperationSpec);
|
|
}
|
|
}
|
|
var xmlSerializer$1 = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var serializer$1 = new coreHttp__namespace.Serializer(Mappers, false);
|
|
var createOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: AppendBlobCreateHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: AppendBlobCreateExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
encryptionScope,
|
|
blobTagsString,
|
|
legalHold1,
|
|
blobType1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$1
|
|
};
|
|
var appendBlockOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: AppendBlobAppendBlockHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: AppendBlobAppendBlockExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body1,
|
|
queryParameters: [timeoutInSeconds, comp22],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64,
|
|
contentType1,
|
|
accept2,
|
|
maxSize,
|
|
appendPosition
|
|
],
|
|
mediaType: "binary",
|
|
serializer: serializer$1
|
|
};
|
|
var appendBlockFromUrlOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: AppendBlobAppendBlockFromUrlHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: AppendBlobAppendBlockFromUrlExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp22],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
encryptionScope,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
sourceContentMD5,
|
|
copySourceAuthorization,
|
|
transactionalContentMD5,
|
|
sourceUrl,
|
|
sourceContentCrc64,
|
|
maxSize,
|
|
appendPosition,
|
|
sourceRange1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$1
|
|
};
|
|
var sealOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
200: {
|
|
headersMapper: AppendBlobSealHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: AppendBlobSealExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds, comp23],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
appendPosition
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer$1
|
|
};
|
|
|
|
class BlockBlob {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
upload(contentLength2, body2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, uploadOperationSpec);
|
|
}
|
|
putBlobFromUrl(contentLength2, copySource2, options) {
|
|
const operationArguments = {
|
|
contentLength: contentLength2,
|
|
copySource: copySource2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, putBlobFromUrlOperationSpec);
|
|
}
|
|
stageBlock(blockId2, contentLength2, body2, options) {
|
|
const operationArguments = {
|
|
blockId: blockId2,
|
|
contentLength: contentLength2,
|
|
body: body2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, stageBlockOperationSpec);
|
|
}
|
|
stageBlockFromURL(blockId2, contentLength2, sourceUrl2, options) {
|
|
const operationArguments = {
|
|
blockId: blockId2,
|
|
contentLength: contentLength2,
|
|
sourceUrl: sourceUrl2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, stageBlockFromURLOperationSpec);
|
|
}
|
|
commitBlockList(blocks2, options) {
|
|
const operationArguments = {
|
|
blocks: blocks2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, commitBlockListOperationSpec);
|
|
}
|
|
getBlockList(listType2, options) {
|
|
const operationArguments = {
|
|
listType: listType2,
|
|
options: coreHttp__namespace.operationOptionsToRequestOptionsBase(options || {})
|
|
};
|
|
return this.client.sendOperationRequest(operationArguments, getBlockListOperationSpec);
|
|
}
|
|
}
|
|
var xmlSerializer = new coreHttp__namespace.Serializer(Mappers, true);
|
|
var serializer = new coreHttp__namespace.Serializer(Mappers, false);
|
|
var uploadOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlockBlobUploadHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobUploadExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body1,
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
encryptionScope,
|
|
tier,
|
|
blobTagsString,
|
|
legalHold1,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64,
|
|
contentType1,
|
|
accept2,
|
|
blobType2
|
|
],
|
|
mediaType: "binary",
|
|
serializer
|
|
};
|
|
var putBlobFromUrlOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlockBlobPutBlobFromUrlHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobPutBlobFromUrlExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [timeoutInSeconds],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition,
|
|
encryptionScope,
|
|
tier,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
sourceIfTags,
|
|
copySource,
|
|
blobTagsString,
|
|
sourceContentMD5,
|
|
copySourceAuthorization,
|
|
copySourceTags,
|
|
transactionalContentMD5,
|
|
blobType2,
|
|
copySourceBlobProperties
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer
|
|
};
|
|
var stageBlockOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlockBlobStageBlockHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobStageBlockExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: body1,
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp24,
|
|
blockId
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
contentLength,
|
|
leaseId,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
encryptionScope,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64,
|
|
contentType1,
|
|
accept2
|
|
],
|
|
mediaType: "binary",
|
|
serializer
|
|
};
|
|
var stageBlockFromURLOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlockBlobStageBlockFromURLHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobStageBlockFromURLExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
comp24,
|
|
blockId
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
contentLength,
|
|
leaseId,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
encryptionScope,
|
|
sourceIfModifiedSince,
|
|
sourceIfUnmodifiedSince,
|
|
sourceIfMatch,
|
|
sourceIfNoneMatch,
|
|
sourceContentMD5,
|
|
copySourceAuthorization,
|
|
sourceUrl,
|
|
sourceContentCrc64,
|
|
sourceRange1
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer
|
|
};
|
|
var commitBlockListOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "PUT",
|
|
responses: {
|
|
201: {
|
|
headersMapper: BlockBlobCommitBlockListHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobCommitBlockListExceptionHeaders
|
|
}
|
|
},
|
|
requestBody: blocks,
|
|
queryParameters: [timeoutInSeconds, comp25],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
contentType,
|
|
accept,
|
|
version3,
|
|
requestId,
|
|
metadata,
|
|
leaseId,
|
|
ifModifiedSince,
|
|
ifUnmodifiedSince,
|
|
encryptionKey,
|
|
encryptionKeySha256,
|
|
encryptionAlgorithm,
|
|
ifMatch,
|
|
ifNoneMatch,
|
|
ifTags,
|
|
blobCacheControl,
|
|
blobContentType,
|
|
blobContentMD5,
|
|
blobContentEncoding,
|
|
blobContentLanguage,
|
|
blobContentDisposition,
|
|
immutabilityPolicyExpiry,
|
|
immutabilityPolicyMode,
|
|
encryptionScope,
|
|
tier,
|
|
blobTagsString,
|
|
legalHold1,
|
|
transactionalContentMD5,
|
|
transactionalContentCrc64
|
|
],
|
|
isXML: true,
|
|
contentType: "application/xml; charset=utf-8",
|
|
mediaType: "xml",
|
|
serializer: xmlSerializer
|
|
};
|
|
var getBlockListOperationSpec = {
|
|
path: "/{containerName}/{blob}",
|
|
httpMethod: "GET",
|
|
responses: {
|
|
200: {
|
|
bodyMapper: BlockList,
|
|
headersMapper: BlockBlobGetBlockListHeaders
|
|
},
|
|
default: {
|
|
bodyMapper: StorageError,
|
|
headersMapper: BlockBlobGetBlockListExceptionHeaders
|
|
}
|
|
},
|
|
queryParameters: [
|
|
timeoutInSeconds,
|
|
snapshot,
|
|
comp25,
|
|
listType
|
|
],
|
|
urlParameters: [url],
|
|
headerParameters: [
|
|
version3,
|
|
requestId,
|
|
accept1,
|
|
leaseId,
|
|
ifTags
|
|
],
|
|
isXML: true,
|
|
serializer: xmlSerializer
|
|
};
|
|
var logger = logger$1.createClientLogger("storage-blob");
|
|
var SDK_VERSION = "12.14.0";
|
|
var SERVICE_VERSION = "2022-11-02";
|
|
var BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES = 256 * 1024 * 1024;
|
|
var BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES = 4000 * 1024 * 1024;
|
|
var BLOCK_BLOB_MAX_BLOCKS = 50000;
|
|
var DEFAULT_BLOCK_BUFFER_SIZE_BYTES = 8 * 1024 * 1024;
|
|
var DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES = 4 * 1024 * 1024;
|
|
var DEFAULT_MAX_DOWNLOAD_RETRY_REQUESTS = 5;
|
|
var REQUEST_TIMEOUT = 100 * 1000;
|
|
var StorageOAuthScopes = "https://storage.azure.com/.default";
|
|
var URLConstants = {
|
|
Parameters: {
|
|
FORCE_BROWSER_NO_CACHE: "_",
|
|
SIGNATURE: "sig",
|
|
SNAPSHOT: "snapshot",
|
|
VERSIONID: "versionid",
|
|
TIMEOUT: "timeout"
|
|
}
|
|
};
|
|
var HTTPURLConnection = {
|
|
HTTP_ACCEPTED: 202,
|
|
HTTP_CONFLICT: 409,
|
|
HTTP_NOT_FOUND: 404,
|
|
HTTP_PRECON_FAILED: 412,
|
|
HTTP_RANGE_NOT_SATISFIABLE: 416
|
|
};
|
|
var HeaderConstants = {
|
|
AUTHORIZATION: "Authorization",
|
|
AUTHORIZATION_SCHEME: "Bearer",
|
|
CONTENT_ENCODING: "Content-Encoding",
|
|
CONTENT_ID: "Content-ID",
|
|
CONTENT_LANGUAGE: "Content-Language",
|
|
CONTENT_LENGTH: "Content-Length",
|
|
CONTENT_MD5: "Content-Md5",
|
|
CONTENT_TRANSFER_ENCODING: "Content-Transfer-Encoding",
|
|
CONTENT_TYPE: "Content-Type",
|
|
COOKIE: "Cookie",
|
|
DATE: "date",
|
|
IF_MATCH: "if-match",
|
|
IF_MODIFIED_SINCE: "if-modified-since",
|
|
IF_NONE_MATCH: "if-none-match",
|
|
IF_UNMODIFIED_SINCE: "if-unmodified-since",
|
|
PREFIX_FOR_STORAGE: "x-ms-",
|
|
RANGE: "Range",
|
|
USER_AGENT: "User-Agent",
|
|
X_MS_CLIENT_REQUEST_ID: "x-ms-client-request-id",
|
|
X_MS_COPY_SOURCE: "x-ms-copy-source",
|
|
X_MS_DATE: "x-ms-date",
|
|
X_MS_ERROR_CODE: "x-ms-error-code",
|
|
X_MS_VERSION: "x-ms-version"
|
|
};
|
|
var ETagNone = "";
|
|
var ETagAny = "*";
|
|
var SIZE_1_MB = 1 * 1024 * 1024;
|
|
var BATCH_MAX_REQUEST = 256;
|
|
var BATCH_MAX_PAYLOAD_IN_BYTES = 4 * SIZE_1_MB;
|
|
var HTTP_LINE_ENDING = "\r\n";
|
|
var HTTP_VERSION_1_1 = "HTTP/1.1";
|
|
var EncryptionAlgorithmAES25 = "AES256";
|
|
var DevelopmentConnectionString = `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;`;
|
|
var StorageBlobLoggingAllowedHeaderNames = [
|
|
"Access-Control-Allow-Origin",
|
|
"Cache-Control",
|
|
"Content-Length",
|
|
"Content-Type",
|
|
"Date",
|
|
"Request-Id",
|
|
"traceparent",
|
|
"Transfer-Encoding",
|
|
"User-Agent",
|
|
"x-ms-client-request-id",
|
|
"x-ms-date",
|
|
"x-ms-error-code",
|
|
"x-ms-request-id",
|
|
"x-ms-return-client-request-id",
|
|
"x-ms-version",
|
|
"Accept-Ranges",
|
|
"Content-Disposition",
|
|
"Content-Encoding",
|
|
"Content-Language",
|
|
"Content-MD5",
|
|
"Content-Range",
|
|
"ETag",
|
|
"Last-Modified",
|
|
"Server",
|
|
"Vary",
|
|
"x-ms-content-crc64",
|
|
"x-ms-copy-action",
|
|
"x-ms-copy-completion-time",
|
|
"x-ms-copy-id",
|
|
"x-ms-copy-progress",
|
|
"x-ms-copy-status",
|
|
"x-ms-has-immutability-policy",
|
|
"x-ms-has-legal-hold",
|
|
"x-ms-lease-state",
|
|
"x-ms-lease-status",
|
|
"x-ms-range",
|
|
"x-ms-request-server-encrypted",
|
|
"x-ms-server-encrypted",
|
|
"x-ms-snapshot",
|
|
"x-ms-source-range",
|
|
"If-Match",
|
|
"If-Modified-Since",
|
|
"If-None-Match",
|
|
"If-Unmodified-Since",
|
|
"x-ms-access-tier",
|
|
"x-ms-access-tier-change-time",
|
|
"x-ms-access-tier-inferred",
|
|
"x-ms-account-kind",
|
|
"x-ms-archive-status",
|
|
"x-ms-blob-append-offset",
|
|
"x-ms-blob-cache-control",
|
|
"x-ms-blob-committed-block-count",
|
|
"x-ms-blob-condition-appendpos",
|
|
"x-ms-blob-condition-maxsize",
|
|
"x-ms-blob-content-disposition",
|
|
"x-ms-blob-content-encoding",
|
|
"x-ms-blob-content-language",
|
|
"x-ms-blob-content-length",
|
|
"x-ms-blob-content-md5",
|
|
"x-ms-blob-content-type",
|
|
"x-ms-blob-public-access",
|
|
"x-ms-blob-sequence-number",
|
|
"x-ms-blob-type",
|
|
"x-ms-copy-destination-snapshot",
|
|
"x-ms-creation-time",
|
|
"x-ms-default-encryption-scope",
|
|
"x-ms-delete-snapshots",
|
|
"x-ms-delete-type-permanent",
|
|
"x-ms-deny-encryption-scope-override",
|
|
"x-ms-encryption-algorithm",
|
|
"x-ms-if-sequence-number-eq",
|
|
"x-ms-if-sequence-number-le",
|
|
"x-ms-if-sequence-number-lt",
|
|
"x-ms-incremental-copy",
|
|
"x-ms-lease-action",
|
|
"x-ms-lease-break-period",
|
|
"x-ms-lease-duration",
|
|
"x-ms-lease-id",
|
|
"x-ms-lease-time",
|
|
"x-ms-page-write",
|
|
"x-ms-proposed-lease-id",
|
|
"x-ms-range-get-content-md5",
|
|
"x-ms-rehydrate-priority",
|
|
"x-ms-sequence-number-action",
|
|
"x-ms-sku-name",
|
|
"x-ms-source-content-md5",
|
|
"x-ms-source-if-match",
|
|
"x-ms-source-if-modified-since",
|
|
"x-ms-source-if-none-match",
|
|
"x-ms-source-if-unmodified-since",
|
|
"x-ms-tag-count",
|
|
"x-ms-encryption-key-sha256",
|
|
"x-ms-if-tags",
|
|
"x-ms-source-if-tags"
|
|
];
|
|
var StorageBlobLoggingAllowedQueryParameters = [
|
|
"comp",
|
|
"maxresults",
|
|
"rscc",
|
|
"rscd",
|
|
"rsce",
|
|
"rscl",
|
|
"rsct",
|
|
"se",
|
|
"si",
|
|
"sip",
|
|
"sp",
|
|
"spr",
|
|
"sr",
|
|
"srt",
|
|
"ss",
|
|
"st",
|
|
"sv",
|
|
"include",
|
|
"marker",
|
|
"prefix",
|
|
"copyid",
|
|
"restype",
|
|
"blockid",
|
|
"blocklisttype",
|
|
"delimiter",
|
|
"prevsnapshot",
|
|
"ske",
|
|
"skoid",
|
|
"sks",
|
|
"skt",
|
|
"sktid",
|
|
"skv",
|
|
"snapshot"
|
|
];
|
|
var BlobUsesCustomerSpecifiedEncryptionMsg = "BlobUsesCustomerSpecifiedEncryption";
|
|
var BlobDoesNotUseCustomerSpecifiedEncryption = "BlobDoesNotUseCustomerSpecifiedEncryption";
|
|
var PathStylePorts = [
|
|
"10000",
|
|
"10001",
|
|
"10002",
|
|
"10003",
|
|
"10004",
|
|
"10100",
|
|
"10101",
|
|
"10102",
|
|
"10103",
|
|
"10104",
|
|
"11000",
|
|
"11001",
|
|
"11002",
|
|
"11003",
|
|
"11004",
|
|
"11100",
|
|
"11101",
|
|
"11102",
|
|
"11103",
|
|
"11104"
|
|
];
|
|
|
|
class StorageBrowserPolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(request) {
|
|
if (coreHttp.isNode)
|
|
return this._nextPolicy.sendRequest(request);
|
|
if (request.method.toUpperCase() === "GET" || request.method.toUpperCase() === "HEAD")
|
|
request.url = setURLParameter(request.url, URLConstants.Parameters.FORCE_BROWSER_NO_CACHE, new Date().getTime().toString());
|
|
request.headers.remove(HeaderConstants.COOKIE);
|
|
request.headers.remove(HeaderConstants.CONTENT_LENGTH);
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
|
|
class StorageBrowserPolicyFactory {
|
|
create(nextPolicy, options) {
|
|
return new StorageBrowserPolicy(nextPolicy, options);
|
|
}
|
|
}
|
|
exports.StorageRetryPolicyType = undefined;
|
|
(function(StorageRetryPolicyType) {
|
|
StorageRetryPolicyType[StorageRetryPolicyType["EXPONENTIAL"] = 0] = "EXPONENTIAL";
|
|
StorageRetryPolicyType[StorageRetryPolicyType["FIXED"] = 1] = "FIXED";
|
|
})(exports.StorageRetryPolicyType || (exports.StorageRetryPolicyType = {}));
|
|
var DEFAULT_RETRY_OPTIONS = {
|
|
maxRetryDelayInMs: 120 * 1000,
|
|
maxTries: 4,
|
|
retryDelayInMs: 4 * 1000,
|
|
retryPolicyType: exports.StorageRetryPolicyType.EXPONENTIAL,
|
|
secondaryHost: "",
|
|
tryTimeoutInMs: undefined
|
|
};
|
|
var RETRY_ABORT_ERROR = new abortController.AbortError("The operation was aborted.");
|
|
|
|
class StorageRetryPolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(nextPolicy, options, retryOptions = DEFAULT_RETRY_OPTIONS) {
|
|
super(nextPolicy, options);
|
|
this.retryOptions = {
|
|
retryPolicyType: retryOptions.retryPolicyType ? retryOptions.retryPolicyType : DEFAULT_RETRY_OPTIONS.retryPolicyType,
|
|
maxTries: retryOptions.maxTries && retryOptions.maxTries >= 1 ? Math.floor(retryOptions.maxTries) : DEFAULT_RETRY_OPTIONS.maxTries,
|
|
tryTimeoutInMs: retryOptions.tryTimeoutInMs && retryOptions.tryTimeoutInMs >= 0 ? retryOptions.tryTimeoutInMs : DEFAULT_RETRY_OPTIONS.tryTimeoutInMs,
|
|
retryDelayInMs: retryOptions.retryDelayInMs && retryOptions.retryDelayInMs >= 0 ? Math.min(retryOptions.retryDelayInMs, retryOptions.maxRetryDelayInMs ? retryOptions.maxRetryDelayInMs : DEFAULT_RETRY_OPTIONS.maxRetryDelayInMs) : DEFAULT_RETRY_OPTIONS.retryDelayInMs,
|
|
maxRetryDelayInMs: retryOptions.maxRetryDelayInMs && retryOptions.maxRetryDelayInMs >= 0 ? retryOptions.maxRetryDelayInMs : DEFAULT_RETRY_OPTIONS.maxRetryDelayInMs,
|
|
secondaryHost: retryOptions.secondaryHost ? retryOptions.secondaryHost : DEFAULT_RETRY_OPTIONS.secondaryHost
|
|
};
|
|
}
|
|
async sendRequest(request) {
|
|
return this.attemptSendRequest(request, false, 1);
|
|
}
|
|
async attemptSendRequest(request, secondaryHas404, attempt) {
|
|
const newRequest = request.clone();
|
|
const isPrimaryRetry = secondaryHas404 || !this.retryOptions.secondaryHost || !(request.method === "GET" || request.method === "HEAD" || request.method === "OPTIONS") || attempt % 2 === 1;
|
|
if (!isPrimaryRetry)
|
|
newRequest.url = setURLHost(newRequest.url, this.retryOptions.secondaryHost);
|
|
if (this.retryOptions.tryTimeoutInMs)
|
|
newRequest.url = setURLParameter(newRequest.url, URLConstants.Parameters.TIMEOUT, Math.floor(this.retryOptions.tryTimeoutInMs / 1000).toString());
|
|
let response;
|
|
try {
|
|
logger.info(`RetryPolicy: =====> Try=${attempt} ${isPrimaryRetry ? "Primary" : "Secondary"}`);
|
|
response = await this._nextPolicy.sendRequest(newRequest);
|
|
if (!this.shouldRetry(isPrimaryRetry, attempt, response))
|
|
return response;
|
|
secondaryHas404 = secondaryHas404 || !isPrimaryRetry && response.status === 404;
|
|
} catch (err) {
|
|
logger.error(`RetryPolicy: Caught error, message: ${err.message}, code: ${err.code}`);
|
|
if (!this.shouldRetry(isPrimaryRetry, attempt, response, err))
|
|
throw err;
|
|
}
|
|
await this.delay(isPrimaryRetry, attempt, request.abortSignal);
|
|
return this.attemptSendRequest(request, secondaryHas404, ++attempt);
|
|
}
|
|
shouldRetry(isPrimaryRetry, attempt, response, err) {
|
|
if (attempt >= this.retryOptions.maxTries) {
|
|
logger.info(`RetryPolicy: Attempt(s) ${attempt} >= maxTries ${this.retryOptions.maxTries}, no further try.`);
|
|
return false;
|
|
}
|
|
const retriableErrors = [
|
|
"ETIMEDOUT",
|
|
"ESOCKETTIMEDOUT",
|
|
"ECONNREFUSED",
|
|
"ECONNRESET",
|
|
"ENOENT",
|
|
"ENOTFOUND",
|
|
"TIMEOUT",
|
|
"EPIPE",
|
|
"REQUEST_SEND_ERROR"
|
|
];
|
|
if (err) {
|
|
for (const retriableError of retriableErrors)
|
|
if (err.name.toUpperCase().includes(retriableError) || err.message.toUpperCase().includes(retriableError) || err.code && err.code.toString().toUpperCase() === retriableError) {
|
|
logger.info(`RetryPolicy: Network error ${retriableError} found, will retry.`);
|
|
return true;
|
|
}
|
|
}
|
|
if (response || err) {
|
|
const statusCode = response ? response.status : err ? err.statusCode : 0;
|
|
if (!isPrimaryRetry && statusCode === 404) {
|
|
logger.info(`RetryPolicy: Secondary access with 404, will retry.`);
|
|
return true;
|
|
}
|
|
if (statusCode === 503 || statusCode === 500) {
|
|
logger.info(`RetryPolicy: Will retry for status code ${statusCode}.`);
|
|
return true;
|
|
}
|
|
}
|
|
if ((err === null || err === undefined ? undefined : err.code) === "PARSE_ERROR" && (err === null || err === undefined ? undefined : err.message.startsWith(`Error "Error: Unclosed root tag`))) {
|
|
logger.info("RetryPolicy: Incomplete XML response likely due to service timeout, will retry.");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
async delay(isPrimaryRetry, attempt, abortSignal) {
|
|
let delayTimeInMs = 0;
|
|
if (isPrimaryRetry)
|
|
switch (this.retryOptions.retryPolicyType) {
|
|
case exports.StorageRetryPolicyType.EXPONENTIAL:
|
|
delayTimeInMs = Math.min((Math.pow(2, attempt - 1) - 1) * this.retryOptions.retryDelayInMs, this.retryOptions.maxRetryDelayInMs);
|
|
break;
|
|
case exports.StorageRetryPolicyType.FIXED:
|
|
delayTimeInMs = this.retryOptions.retryDelayInMs;
|
|
break;
|
|
}
|
|
else
|
|
delayTimeInMs = Math.random() * 1000;
|
|
logger.info(`RetryPolicy: Delay for ${delayTimeInMs}ms`);
|
|
return delay(delayTimeInMs, abortSignal, RETRY_ABORT_ERROR);
|
|
}
|
|
}
|
|
|
|
class StorageRetryPolicyFactory {
|
|
constructor(retryOptions) {
|
|
this.retryOptions = retryOptions;
|
|
}
|
|
create(nextPolicy, options) {
|
|
return new StorageRetryPolicy(nextPolicy, options, this.retryOptions);
|
|
}
|
|
}
|
|
|
|
class CredentialPolicy extends coreHttp.BaseRequestPolicy {
|
|
sendRequest(request) {
|
|
return this._nextPolicy.sendRequest(this.signRequest(request));
|
|
}
|
|
signRequest(request) {
|
|
return request;
|
|
}
|
|
}
|
|
|
|
class AnonymousCredentialPolicy extends CredentialPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
}
|
|
|
|
class Credential {
|
|
create(_nextPolicy, _options) {
|
|
throw new Error("Method should be implemented in children classes.");
|
|
}
|
|
}
|
|
|
|
class AnonymousCredential extends Credential {
|
|
create(nextPolicy, options) {
|
|
return new AnonymousCredentialPolicy(nextPolicy, options);
|
|
}
|
|
}
|
|
|
|
class TelemetryPolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(nextPolicy, options, telemetry) {
|
|
super(nextPolicy, options);
|
|
this.telemetry = telemetry;
|
|
}
|
|
async sendRequest(request) {
|
|
if (coreHttp.isNode) {
|
|
if (!request.headers)
|
|
request.headers = new coreHttp.HttpHeaders;
|
|
if (!request.headers.get(HeaderConstants.USER_AGENT))
|
|
request.headers.set(HeaderConstants.USER_AGENT, this.telemetry);
|
|
}
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
|
|
class TelemetryPolicyFactory {
|
|
constructor(telemetry) {
|
|
const userAgentInfo = [];
|
|
if (coreHttp.isNode) {
|
|
if (telemetry) {
|
|
const telemetryString = telemetry.userAgentPrefix || "";
|
|
if (telemetryString.length > 0 && userAgentInfo.indexOf(telemetryString) === -1)
|
|
userAgentInfo.push(telemetryString);
|
|
}
|
|
const libInfo = `azsdk-js-storageblob/${SDK_VERSION}`;
|
|
if (userAgentInfo.indexOf(libInfo) === -1)
|
|
userAgentInfo.push(libInfo);
|
|
let runtimeInfo = `(NODE-VERSION ${process.version})`;
|
|
if (os__namespace)
|
|
runtimeInfo = `(NODE-VERSION ${process.version}; ${os__namespace.type()} ${os__namespace.release()})`;
|
|
if (userAgentInfo.indexOf(runtimeInfo) === -1)
|
|
userAgentInfo.push(runtimeInfo);
|
|
}
|
|
this.telemetryString = userAgentInfo.join(" ");
|
|
}
|
|
create(nextPolicy, options) {
|
|
return new TelemetryPolicy(nextPolicy, options, this.telemetryString);
|
|
}
|
|
}
|
|
var _defaultHttpClient = new coreHttp.DefaultHttpClient;
|
|
var Constants = {
|
|
DefaultScope: "/.default",
|
|
HeaderConstants: {
|
|
AUTHORIZATION: "authorization"
|
|
}
|
|
};
|
|
var DEFAULT_CYCLER_OPTIONS = {
|
|
forcedRefreshWindowInMs: 1000,
|
|
retryIntervalInMs: 3000,
|
|
refreshWindowInMs: 1000 * 60 * 2
|
|
};
|
|
|
|
class Pipeline {
|
|
constructor(factories, options = {}) {
|
|
this.factories = factories;
|
|
this.options = Object.assign(Object.assign({}, options), { httpClient: options.httpClient || getCachedDefaultHttpClient() });
|
|
}
|
|
toServiceClientOptions() {
|
|
return {
|
|
httpClient: this.options.httpClient,
|
|
requestPolicyFactories: this.factories
|
|
};
|
|
}
|
|
}
|
|
|
|
class StorageSharedKeyCredentialPolicy extends CredentialPolicy {
|
|
constructor(nextPolicy, options, factory) {
|
|
super(nextPolicy, options);
|
|
this.factory = factory;
|
|
}
|
|
signRequest(request) {
|
|
request.headers.set(HeaderConstants.X_MS_DATE, new Date().toUTCString());
|
|
if (request.body && (typeof request.body === "string" || request.body !== undefined) && request.body.length > 0)
|
|
request.headers.set(HeaderConstants.CONTENT_LENGTH, Buffer.byteLength(request.body));
|
|
const stringToSign = [
|
|
request.method.toUpperCase(),
|
|
this.getHeaderValueToSign(request, HeaderConstants.CONTENT_LANGUAGE),
|
|
this.getHeaderValueToSign(request, HeaderConstants.CONTENT_ENCODING),
|
|
this.getHeaderValueToSign(request, HeaderConstants.CONTENT_LENGTH),
|
|
this.getHeaderValueToSign(request, HeaderConstants.CONTENT_MD5),
|
|
this.getHeaderValueToSign(request, HeaderConstants.CONTENT_TYPE),
|
|
this.getHeaderValueToSign(request, HeaderConstants.DATE),
|
|
this.getHeaderValueToSign(request, HeaderConstants.IF_MODIFIED_SINCE),
|
|
this.getHeaderValueToSign(request, HeaderConstants.IF_MATCH),
|
|
this.getHeaderValueToSign(request, HeaderConstants.IF_NONE_MATCH),
|
|
this.getHeaderValueToSign(request, HeaderConstants.IF_UNMODIFIED_SINCE),
|
|
this.getHeaderValueToSign(request, HeaderConstants.RANGE)
|
|
].join("\n") + "\n" + this.getCanonicalizedHeadersString(request) + this.getCanonicalizedResourceString(request);
|
|
const signature = this.factory.computeHMACSHA256(stringToSign);
|
|
request.headers.set(HeaderConstants.AUTHORIZATION, `SharedKey ${this.factory.accountName}:${signature}`);
|
|
return request;
|
|
}
|
|
getHeaderValueToSign(request, headerName) {
|
|
const value = request.headers.get(headerName);
|
|
if (!value)
|
|
return "";
|
|
if (headerName === HeaderConstants.CONTENT_LENGTH && value === "0")
|
|
return "";
|
|
return value;
|
|
}
|
|
getCanonicalizedHeadersString(request) {
|
|
let headersArray = request.headers.headersArray().filter((value) => {
|
|
return value.name.toLowerCase().startsWith(HeaderConstants.PREFIX_FOR_STORAGE);
|
|
});
|
|
headersArray.sort((a, b) => {
|
|
return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
|
|
});
|
|
headersArray = headersArray.filter((value, index, array) => {
|
|
if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase())
|
|
return false;
|
|
return true;
|
|
});
|
|
let canonicalizedHeadersStringToSign = "";
|
|
headersArray.forEach((header) => {
|
|
canonicalizedHeadersStringToSign += `${header.name.toLowerCase().trimRight()}:${header.value.trimLeft()}\n`;
|
|
});
|
|
return canonicalizedHeadersStringToSign;
|
|
}
|
|
getCanonicalizedResourceString(request) {
|
|
const path = getURLPath(request.url) || "/";
|
|
let canonicalizedResourceString = "";
|
|
canonicalizedResourceString += `/${this.factory.accountName}${path}`;
|
|
const queries = getURLQueries(request.url);
|
|
const lowercaseQueries = {};
|
|
if (queries) {
|
|
const queryKeys = [];
|
|
for (const key in queries)
|
|
if (Object.prototype.hasOwnProperty.call(queries, key)) {
|
|
const lowercaseKey = key.toLowerCase();
|
|
lowercaseQueries[lowercaseKey] = queries[key];
|
|
queryKeys.push(lowercaseKey);
|
|
}
|
|
queryKeys.sort();
|
|
for (const key of queryKeys)
|
|
canonicalizedResourceString += `\n${key}:${decodeURIComponent(lowercaseQueries[key])}`;
|
|
}
|
|
return canonicalizedResourceString;
|
|
}
|
|
}
|
|
|
|
class StorageSharedKeyCredential extends Credential {
|
|
constructor(accountName, accountKey) {
|
|
super();
|
|
this.accountName = accountName;
|
|
this.accountKey = Buffer.from(accountKey, "base64");
|
|
}
|
|
create(nextPolicy, options) {
|
|
return new StorageSharedKeyCredentialPolicy(nextPolicy, options, this);
|
|
}
|
|
computeHMACSHA256(stringToSign) {
|
|
return crypto7.createHmac("sha256", this.accountKey).update(stringToSign, "utf8").digest("base64");
|
|
}
|
|
}
|
|
var packageName = "azure-storage-blob";
|
|
var packageVersion = "12.14.0";
|
|
|
|
class StorageClientContext extends coreHttp__namespace.ServiceClient {
|
|
constructor(url2, options) {
|
|
if (url2 === undefined)
|
|
throw new Error("'url' cannot be null");
|
|
if (!options)
|
|
options = {};
|
|
if (!options.userAgent) {
|
|
const defaultUserAgent = coreHttp__namespace.getDefaultUserAgentValue();
|
|
options.userAgent = `${packageName}/${packageVersion} ${defaultUserAgent}`;
|
|
}
|
|
super(undefined, options);
|
|
this.requestContentType = "application/json; charset=utf-8";
|
|
this.baseUri = options.endpoint || "{url}";
|
|
this.url = url2;
|
|
this.version = options.version || "2022-11-02";
|
|
}
|
|
}
|
|
|
|
class StorageClient {
|
|
constructor(url2, pipeline) {
|
|
this.url = escapeURLPath(url2);
|
|
this.accountName = getAccountNameFromUrl(url2);
|
|
this.pipeline = pipeline;
|
|
this.storageClientContext = new StorageClientContext(this.url, pipeline.toServiceClientOptions());
|
|
this.isHttps = iEqual(getURLScheme(this.url) || "", "https");
|
|
this.credential = new AnonymousCredential;
|
|
for (const factory of this.pipeline.factories)
|
|
if (coreHttp.isNode && factory instanceof StorageSharedKeyCredential || factory instanceof AnonymousCredential)
|
|
this.credential = factory;
|
|
else if (coreHttp.isTokenCredential(factory.credential))
|
|
this.credential = factory.credential;
|
|
const storageClientContext = this.storageClientContext;
|
|
storageClientContext.requestContentType = undefined;
|
|
}
|
|
}
|
|
var createSpan = coreTracing.createSpanFunction({
|
|
packagePrefix: "Azure.Storage.Blob",
|
|
namespace: "Microsoft.Storage"
|
|
});
|
|
|
|
class BlobSASPermissions {
|
|
constructor() {
|
|
this.read = false;
|
|
this.add = false;
|
|
this.create = false;
|
|
this.write = false;
|
|
this.delete = false;
|
|
this.deleteVersion = false;
|
|
this.tag = false;
|
|
this.move = false;
|
|
this.execute = false;
|
|
this.setImmutabilityPolicy = false;
|
|
this.permanentDelete = false;
|
|
}
|
|
static parse(permissions) {
|
|
const blobSASPermissions = new BlobSASPermissions;
|
|
for (const char of permissions)
|
|
switch (char) {
|
|
case "r":
|
|
blobSASPermissions.read = true;
|
|
break;
|
|
case "a":
|
|
blobSASPermissions.add = true;
|
|
break;
|
|
case "c":
|
|
blobSASPermissions.create = true;
|
|
break;
|
|
case "w":
|
|
blobSASPermissions.write = true;
|
|
break;
|
|
case "d":
|
|
blobSASPermissions.delete = true;
|
|
break;
|
|
case "x":
|
|
blobSASPermissions.deleteVersion = true;
|
|
break;
|
|
case "t":
|
|
blobSASPermissions.tag = true;
|
|
break;
|
|
case "m":
|
|
blobSASPermissions.move = true;
|
|
break;
|
|
case "e":
|
|
blobSASPermissions.execute = true;
|
|
break;
|
|
case "i":
|
|
blobSASPermissions.setImmutabilityPolicy = true;
|
|
break;
|
|
case "y":
|
|
blobSASPermissions.permanentDelete = true;
|
|
break;
|
|
default:
|
|
throw new RangeError(`Invalid permission: ${char}`);
|
|
}
|
|
return blobSASPermissions;
|
|
}
|
|
static from(permissionLike) {
|
|
const blobSASPermissions = new BlobSASPermissions;
|
|
if (permissionLike.read)
|
|
blobSASPermissions.read = true;
|
|
if (permissionLike.add)
|
|
blobSASPermissions.add = true;
|
|
if (permissionLike.create)
|
|
blobSASPermissions.create = true;
|
|
if (permissionLike.write)
|
|
blobSASPermissions.write = true;
|
|
if (permissionLike.delete)
|
|
blobSASPermissions.delete = true;
|
|
if (permissionLike.deleteVersion)
|
|
blobSASPermissions.deleteVersion = true;
|
|
if (permissionLike.tag)
|
|
blobSASPermissions.tag = true;
|
|
if (permissionLike.move)
|
|
blobSASPermissions.move = true;
|
|
if (permissionLike.execute)
|
|
blobSASPermissions.execute = true;
|
|
if (permissionLike.setImmutabilityPolicy)
|
|
blobSASPermissions.setImmutabilityPolicy = true;
|
|
if (permissionLike.permanentDelete)
|
|
blobSASPermissions.permanentDelete = true;
|
|
return blobSASPermissions;
|
|
}
|
|
toString() {
|
|
const permissions = [];
|
|
if (this.read)
|
|
permissions.push("r");
|
|
if (this.add)
|
|
permissions.push("a");
|
|
if (this.create)
|
|
permissions.push("c");
|
|
if (this.write)
|
|
permissions.push("w");
|
|
if (this.delete)
|
|
permissions.push("d");
|
|
if (this.deleteVersion)
|
|
permissions.push("x");
|
|
if (this.tag)
|
|
permissions.push("t");
|
|
if (this.move)
|
|
permissions.push("m");
|
|
if (this.execute)
|
|
permissions.push("e");
|
|
if (this.setImmutabilityPolicy)
|
|
permissions.push("i");
|
|
if (this.permanentDelete)
|
|
permissions.push("y");
|
|
return permissions.join("");
|
|
}
|
|
}
|
|
|
|
class ContainerSASPermissions {
|
|
constructor() {
|
|
this.read = false;
|
|
this.add = false;
|
|
this.create = false;
|
|
this.write = false;
|
|
this.delete = false;
|
|
this.deleteVersion = false;
|
|
this.list = false;
|
|
this.tag = false;
|
|
this.move = false;
|
|
this.execute = false;
|
|
this.setImmutabilityPolicy = false;
|
|
this.permanentDelete = false;
|
|
this.filterByTags = false;
|
|
}
|
|
static parse(permissions) {
|
|
const containerSASPermissions = new ContainerSASPermissions;
|
|
for (const char of permissions)
|
|
switch (char) {
|
|
case "r":
|
|
containerSASPermissions.read = true;
|
|
break;
|
|
case "a":
|
|
containerSASPermissions.add = true;
|
|
break;
|
|
case "c":
|
|
containerSASPermissions.create = true;
|
|
break;
|
|
case "w":
|
|
containerSASPermissions.write = true;
|
|
break;
|
|
case "d":
|
|
containerSASPermissions.delete = true;
|
|
break;
|
|
case "l":
|
|
containerSASPermissions.list = true;
|
|
break;
|
|
case "t":
|
|
containerSASPermissions.tag = true;
|
|
break;
|
|
case "x":
|
|
containerSASPermissions.deleteVersion = true;
|
|
break;
|
|
case "m":
|
|
containerSASPermissions.move = true;
|
|
break;
|
|
case "e":
|
|
containerSASPermissions.execute = true;
|
|
break;
|
|
case "i":
|
|
containerSASPermissions.setImmutabilityPolicy = true;
|
|
break;
|
|
case "y":
|
|
containerSASPermissions.permanentDelete = true;
|
|
break;
|
|
case "f":
|
|
containerSASPermissions.filterByTags = true;
|
|
break;
|
|
default:
|
|
throw new RangeError(`Invalid permission ${char}`);
|
|
}
|
|
return containerSASPermissions;
|
|
}
|
|
static from(permissionLike) {
|
|
const containerSASPermissions = new ContainerSASPermissions;
|
|
if (permissionLike.read)
|
|
containerSASPermissions.read = true;
|
|
if (permissionLike.add)
|
|
containerSASPermissions.add = true;
|
|
if (permissionLike.create)
|
|
containerSASPermissions.create = true;
|
|
if (permissionLike.write)
|
|
containerSASPermissions.write = true;
|
|
if (permissionLike.delete)
|
|
containerSASPermissions.delete = true;
|
|
if (permissionLike.list)
|
|
containerSASPermissions.list = true;
|
|
if (permissionLike.deleteVersion)
|
|
containerSASPermissions.deleteVersion = true;
|
|
if (permissionLike.tag)
|
|
containerSASPermissions.tag = true;
|
|
if (permissionLike.move)
|
|
containerSASPermissions.move = true;
|
|
if (permissionLike.execute)
|
|
containerSASPermissions.execute = true;
|
|
if (permissionLike.setImmutabilityPolicy)
|
|
containerSASPermissions.setImmutabilityPolicy = true;
|
|
if (permissionLike.permanentDelete)
|
|
containerSASPermissions.permanentDelete = true;
|
|
if (permissionLike.filterByTags)
|
|
containerSASPermissions.filterByTags = true;
|
|
return containerSASPermissions;
|
|
}
|
|
toString() {
|
|
const permissions = [];
|
|
if (this.read)
|
|
permissions.push("r");
|
|
if (this.add)
|
|
permissions.push("a");
|
|
if (this.create)
|
|
permissions.push("c");
|
|
if (this.write)
|
|
permissions.push("w");
|
|
if (this.delete)
|
|
permissions.push("d");
|
|
if (this.deleteVersion)
|
|
permissions.push("x");
|
|
if (this.list)
|
|
permissions.push("l");
|
|
if (this.tag)
|
|
permissions.push("t");
|
|
if (this.move)
|
|
permissions.push("m");
|
|
if (this.execute)
|
|
permissions.push("e");
|
|
if (this.setImmutabilityPolicy)
|
|
permissions.push("i");
|
|
if (this.permanentDelete)
|
|
permissions.push("y");
|
|
if (this.filterByTags)
|
|
permissions.push("f");
|
|
return permissions.join("");
|
|
}
|
|
}
|
|
|
|
class UserDelegationKeyCredential {
|
|
constructor(accountName, userDelegationKey) {
|
|
this.accountName = accountName;
|
|
this.userDelegationKey = userDelegationKey;
|
|
this.key = Buffer.from(userDelegationKey.value, "base64");
|
|
}
|
|
computeHMACSHA256(stringToSign) {
|
|
return crypto7.createHmac("sha256", this.key).update(stringToSign, "utf8").digest("base64");
|
|
}
|
|
}
|
|
exports.SASProtocol = undefined;
|
|
(function(SASProtocol) {
|
|
SASProtocol["Https"] = "https";
|
|
SASProtocol["HttpsAndHttp"] = "https,http";
|
|
})(exports.SASProtocol || (exports.SASProtocol = {}));
|
|
|
|
class SASQueryParameters {
|
|
constructor(version4, signature, permissionsOrOptions, services, resourceTypes, protocol, startsOn, expiresOn2, ipRange, identifier, resource, cacheControl, contentDisposition, contentEncoding, contentLanguage, contentType2, userDelegationKey, preauthorizedAgentObjectId, correlationId, encryptionScope2) {
|
|
this.version = version4;
|
|
this.signature = signature;
|
|
if (permissionsOrOptions !== undefined && typeof permissionsOrOptions !== "string") {
|
|
this.permissions = permissionsOrOptions.permissions;
|
|
this.services = permissionsOrOptions.services;
|
|
this.resourceTypes = permissionsOrOptions.resourceTypes;
|
|
this.protocol = permissionsOrOptions.protocol;
|
|
this.startsOn = permissionsOrOptions.startsOn;
|
|
this.expiresOn = permissionsOrOptions.expiresOn;
|
|
this.ipRangeInner = permissionsOrOptions.ipRange;
|
|
this.identifier = permissionsOrOptions.identifier;
|
|
this.encryptionScope = permissionsOrOptions.encryptionScope;
|
|
this.resource = permissionsOrOptions.resource;
|
|
this.cacheControl = permissionsOrOptions.cacheControl;
|
|
this.contentDisposition = permissionsOrOptions.contentDisposition;
|
|
this.contentEncoding = permissionsOrOptions.contentEncoding;
|
|
this.contentLanguage = permissionsOrOptions.contentLanguage;
|
|
this.contentType = permissionsOrOptions.contentType;
|
|
if (permissionsOrOptions.userDelegationKey) {
|
|
this.signedOid = permissionsOrOptions.userDelegationKey.signedObjectId;
|
|
this.signedTenantId = permissionsOrOptions.userDelegationKey.signedTenantId;
|
|
this.signedStartsOn = permissionsOrOptions.userDelegationKey.signedStartsOn;
|
|
this.signedExpiresOn = permissionsOrOptions.userDelegationKey.signedExpiresOn;
|
|
this.signedService = permissionsOrOptions.userDelegationKey.signedService;
|
|
this.signedVersion = permissionsOrOptions.userDelegationKey.signedVersion;
|
|
this.preauthorizedAgentObjectId = permissionsOrOptions.preauthorizedAgentObjectId;
|
|
this.correlationId = permissionsOrOptions.correlationId;
|
|
}
|
|
} else {
|
|
this.services = services;
|
|
this.resourceTypes = resourceTypes;
|
|
this.expiresOn = expiresOn2;
|
|
this.permissions = permissionsOrOptions;
|
|
this.protocol = protocol;
|
|
this.startsOn = startsOn;
|
|
this.ipRangeInner = ipRange;
|
|
this.encryptionScope = encryptionScope2;
|
|
this.identifier = identifier;
|
|
this.resource = resource;
|
|
this.cacheControl = cacheControl;
|
|
this.contentDisposition = contentDisposition;
|
|
this.contentEncoding = contentEncoding;
|
|
this.contentLanguage = contentLanguage;
|
|
this.contentType = contentType2;
|
|
if (userDelegationKey) {
|
|
this.signedOid = userDelegationKey.signedObjectId;
|
|
this.signedTenantId = userDelegationKey.signedTenantId;
|
|
this.signedStartsOn = userDelegationKey.signedStartsOn;
|
|
this.signedExpiresOn = userDelegationKey.signedExpiresOn;
|
|
this.signedService = userDelegationKey.signedService;
|
|
this.signedVersion = userDelegationKey.signedVersion;
|
|
this.preauthorizedAgentObjectId = preauthorizedAgentObjectId;
|
|
this.correlationId = correlationId;
|
|
}
|
|
}
|
|
}
|
|
get ipRange() {
|
|
if (this.ipRangeInner)
|
|
return {
|
|
end: this.ipRangeInner.end,
|
|
start: this.ipRangeInner.start
|
|
};
|
|
return;
|
|
}
|
|
toString() {
|
|
const params = [
|
|
"sv",
|
|
"ss",
|
|
"srt",
|
|
"spr",
|
|
"st",
|
|
"se",
|
|
"sip",
|
|
"si",
|
|
"ses",
|
|
"skoid",
|
|
"sktid",
|
|
"skt",
|
|
"ske",
|
|
"sks",
|
|
"skv",
|
|
"sr",
|
|
"sp",
|
|
"sig",
|
|
"rscc",
|
|
"rscd",
|
|
"rsce",
|
|
"rscl",
|
|
"rsct",
|
|
"saoid",
|
|
"scid"
|
|
];
|
|
const queries = [];
|
|
for (const param of params)
|
|
switch (param) {
|
|
case "sv":
|
|
this.tryAppendQueryParameter(queries, param, this.version);
|
|
break;
|
|
case "ss":
|
|
this.tryAppendQueryParameter(queries, param, this.services);
|
|
break;
|
|
case "srt":
|
|
this.tryAppendQueryParameter(queries, param, this.resourceTypes);
|
|
break;
|
|
case "spr":
|
|
this.tryAppendQueryParameter(queries, param, this.protocol);
|
|
break;
|
|
case "st":
|
|
this.tryAppendQueryParameter(queries, param, this.startsOn ? truncatedISO8061Date(this.startsOn, false) : undefined);
|
|
break;
|
|
case "se":
|
|
this.tryAppendQueryParameter(queries, param, this.expiresOn ? truncatedISO8061Date(this.expiresOn, false) : undefined);
|
|
break;
|
|
case "sip":
|
|
this.tryAppendQueryParameter(queries, param, this.ipRange ? ipRangeToString(this.ipRange) : undefined);
|
|
break;
|
|
case "si":
|
|
this.tryAppendQueryParameter(queries, param, this.identifier);
|
|
break;
|
|
case "ses":
|
|
this.tryAppendQueryParameter(queries, param, this.encryptionScope);
|
|
break;
|
|
case "skoid":
|
|
this.tryAppendQueryParameter(queries, param, this.signedOid);
|
|
break;
|
|
case "sktid":
|
|
this.tryAppendQueryParameter(queries, param, this.signedTenantId);
|
|
break;
|
|
case "skt":
|
|
this.tryAppendQueryParameter(queries, param, this.signedStartsOn ? truncatedISO8061Date(this.signedStartsOn, false) : undefined);
|
|
break;
|
|
case "ske":
|
|
this.tryAppendQueryParameter(queries, param, this.signedExpiresOn ? truncatedISO8061Date(this.signedExpiresOn, false) : undefined);
|
|
break;
|
|
case "sks":
|
|
this.tryAppendQueryParameter(queries, param, this.signedService);
|
|
break;
|
|
case "skv":
|
|
this.tryAppendQueryParameter(queries, param, this.signedVersion);
|
|
break;
|
|
case "sr":
|
|
this.tryAppendQueryParameter(queries, param, this.resource);
|
|
break;
|
|
case "sp":
|
|
this.tryAppendQueryParameter(queries, param, this.permissions);
|
|
break;
|
|
case "sig":
|
|
this.tryAppendQueryParameter(queries, param, this.signature);
|
|
break;
|
|
case "rscc":
|
|
this.tryAppendQueryParameter(queries, param, this.cacheControl);
|
|
break;
|
|
case "rscd":
|
|
this.tryAppendQueryParameter(queries, param, this.contentDisposition);
|
|
break;
|
|
case "rsce":
|
|
this.tryAppendQueryParameter(queries, param, this.contentEncoding);
|
|
break;
|
|
case "rscl":
|
|
this.tryAppendQueryParameter(queries, param, this.contentLanguage);
|
|
break;
|
|
case "rsct":
|
|
this.tryAppendQueryParameter(queries, param, this.contentType);
|
|
break;
|
|
case "saoid":
|
|
this.tryAppendQueryParameter(queries, param, this.preauthorizedAgentObjectId);
|
|
break;
|
|
case "scid":
|
|
this.tryAppendQueryParameter(queries, param, this.correlationId);
|
|
break;
|
|
}
|
|
return queries.join("&");
|
|
}
|
|
tryAppendQueryParameter(queries, key, value) {
|
|
if (!value)
|
|
return;
|
|
key = encodeURIComponent(key);
|
|
value = encodeURIComponent(value);
|
|
if (key.length > 0 && value.length > 0)
|
|
queries.push(`${key}=${value}`);
|
|
}
|
|
}
|
|
|
|
class BlobLeaseClient {
|
|
constructor(client, leaseId2) {
|
|
const clientContext = new StorageClientContext(client.url, client.pipeline.toServiceClientOptions());
|
|
this._url = client.url;
|
|
if (client.name === undefined) {
|
|
this._isContainer = true;
|
|
this._containerOrBlobOperation = new Container(clientContext);
|
|
} else {
|
|
this._isContainer = false;
|
|
this._containerOrBlobOperation = new Blob$1(clientContext);
|
|
}
|
|
if (!leaseId2)
|
|
leaseId2 = coreHttp.generateUuid();
|
|
this._leaseId = leaseId2;
|
|
}
|
|
get leaseId() {
|
|
return this._leaseId;
|
|
}
|
|
get url() {
|
|
return this._url;
|
|
}
|
|
async acquireLease(duration2, options = {}) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const { span, updatedOptions } = createSpan("BlobLeaseClient-acquireLease", options);
|
|
if (this._isContainer && (((_a = options.conditions) === null || _a === undefined ? undefined : _a.ifMatch) && ((_b = options.conditions) === null || _b === undefined ? undefined : _b.ifMatch) !== ETagNone || ((_c = options.conditions) === null || _c === undefined ? undefined : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === undefined ? undefined : _d.ifNoneMatch) !== ETagNone || ((_e = options.conditions) === null || _e === undefined ? undefined : _e.tagConditions)))
|
|
throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
|
|
try {
|
|
return await this._containerOrBlobOperation.acquireLease(Object.assign({ abortSignal: options.abortSignal, duration: duration2, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_f = options.conditions) === null || _f === undefined ? undefined : _f.tagConditions }), proposedLeaseId: this._leaseId }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async changeLease(proposedLeaseId2, options = {}) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const { span, updatedOptions } = createSpan("BlobLeaseClient-changeLease", options);
|
|
if (this._isContainer && (((_a = options.conditions) === null || _a === undefined ? undefined : _a.ifMatch) && ((_b = options.conditions) === null || _b === undefined ? undefined : _b.ifMatch) !== ETagNone || ((_c = options.conditions) === null || _c === undefined ? undefined : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === undefined ? undefined : _d.ifNoneMatch) !== ETagNone || ((_e = options.conditions) === null || _e === undefined ? undefined : _e.tagConditions)))
|
|
throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
|
|
try {
|
|
const response = await this._containerOrBlobOperation.changeLease(this._leaseId, proposedLeaseId2, Object.assign({ abortSignal: options.abortSignal, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_f = options.conditions) === null || _f === undefined ? undefined : _f.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
this._leaseId = proposedLeaseId2;
|
|
return response;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async releaseLease(options = {}) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const { span, updatedOptions } = createSpan("BlobLeaseClient-releaseLease", options);
|
|
if (this._isContainer && (((_a = options.conditions) === null || _a === undefined ? undefined : _a.ifMatch) && ((_b = options.conditions) === null || _b === undefined ? undefined : _b.ifMatch) !== ETagNone || ((_c = options.conditions) === null || _c === undefined ? undefined : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === undefined ? undefined : _d.ifNoneMatch) !== ETagNone || ((_e = options.conditions) === null || _e === undefined ? undefined : _e.tagConditions)))
|
|
throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
|
|
try {
|
|
return await this._containerOrBlobOperation.releaseLease(this._leaseId, Object.assign({ abortSignal: options.abortSignal, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_f = options.conditions) === null || _f === undefined ? undefined : _f.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async renewLease(options = {}) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const { span, updatedOptions } = createSpan("BlobLeaseClient-renewLease", options);
|
|
if (this._isContainer && (((_a = options.conditions) === null || _a === undefined ? undefined : _a.ifMatch) && ((_b = options.conditions) === null || _b === undefined ? undefined : _b.ifMatch) !== ETagNone || ((_c = options.conditions) === null || _c === undefined ? undefined : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === undefined ? undefined : _d.ifNoneMatch) !== ETagNone || ((_e = options.conditions) === null || _e === undefined ? undefined : _e.tagConditions)))
|
|
throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
|
|
try {
|
|
return await this._containerOrBlobOperation.renewLease(this._leaseId, Object.assign({ abortSignal: options.abortSignal, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_f = options.conditions) === null || _f === undefined ? undefined : _f.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async breakLease(breakPeriod2, options = {}) {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const { span, updatedOptions } = createSpan("BlobLeaseClient-breakLease", options);
|
|
if (this._isContainer && (((_a = options.conditions) === null || _a === undefined ? undefined : _a.ifMatch) && ((_b = options.conditions) === null || _b === undefined ? undefined : _b.ifMatch) !== ETagNone || ((_c = options.conditions) === null || _c === undefined ? undefined : _c.ifNoneMatch) && ((_d = options.conditions) === null || _d === undefined ? undefined : _d.ifNoneMatch) !== ETagNone || ((_e = options.conditions) === null || _e === undefined ? undefined : _e.tagConditions)))
|
|
throw new RangeError("The IfMatch, IfNoneMatch and tags access conditions are ignored by the service. Values other than undefined or their default values are not acceptable.");
|
|
try {
|
|
const operationOptions = Object.assign({ abortSignal: options.abortSignal, breakPeriod: breakPeriod2, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_f = options.conditions) === null || _f === undefined ? undefined : _f.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions));
|
|
return await this._containerOrBlobOperation.breakLease(operationOptions);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class RetriableReadableStream extends stream.Readable {
|
|
constructor(source, getter, offset, count, options = {}) {
|
|
super({ highWaterMark: options.highWaterMark });
|
|
this.retries = 0;
|
|
this.sourceDataHandler = (data) => {
|
|
if (this.options.doInjectErrorOnce) {
|
|
this.options.doInjectErrorOnce = undefined;
|
|
this.source.pause();
|
|
this.source.removeAllListeners("data");
|
|
this.source.emit("end");
|
|
return;
|
|
}
|
|
this.offset += data.length;
|
|
if (this.onProgress)
|
|
this.onProgress({ loadedBytes: this.offset - this.start });
|
|
if (!this.push(data))
|
|
this.source.pause();
|
|
};
|
|
this.sourceErrorOrEndHandler = (err) => {
|
|
if (err && err.name === "AbortError") {
|
|
this.destroy(err);
|
|
return;
|
|
}
|
|
this.removeSourceEventHandlers();
|
|
if (this.offset - 1 === this.end)
|
|
this.push(null);
|
|
else if (this.offset <= this.end)
|
|
if (this.retries < this.maxRetryRequests) {
|
|
this.retries += 1;
|
|
this.getter(this.offset).then((newSource) => {
|
|
this.source = newSource;
|
|
this.setSourceEventHandlers();
|
|
return;
|
|
}).catch((error) => {
|
|
this.destroy(error);
|
|
});
|
|
} else
|
|
this.destroy(new Error(`Data corruption failure: received less data than required and reached maxRetires limitation. Received data offset: ${this.offset - 1}, data needed offset: ${this.end}, retries: ${this.retries}, max retries: ${this.maxRetryRequests}`));
|
|
else
|
|
this.destroy(new Error(`Data corruption failure: Received more data than original request, data needed offset is ${this.end}, received offset: ${this.offset - 1}`));
|
|
};
|
|
this.getter = getter;
|
|
this.source = source;
|
|
this.start = offset;
|
|
this.offset = offset;
|
|
this.end = offset + count - 1;
|
|
this.maxRetryRequests = options.maxRetryRequests && options.maxRetryRequests >= 0 ? options.maxRetryRequests : 0;
|
|
this.onProgress = options.onProgress;
|
|
this.options = options;
|
|
this.setSourceEventHandlers();
|
|
}
|
|
_read() {
|
|
this.source.resume();
|
|
}
|
|
setSourceEventHandlers() {
|
|
this.source.on("data", this.sourceDataHandler);
|
|
this.source.on("end", this.sourceErrorOrEndHandler);
|
|
this.source.on("error", this.sourceErrorOrEndHandler);
|
|
}
|
|
removeSourceEventHandlers() {
|
|
this.source.removeListener("data", this.sourceDataHandler);
|
|
this.source.removeListener("end", this.sourceErrorOrEndHandler);
|
|
this.source.removeListener("error", this.sourceErrorOrEndHandler);
|
|
}
|
|
_destroy(error, callback) {
|
|
this.removeSourceEventHandlers();
|
|
this.source.destroy();
|
|
callback(error === null ? undefined : error);
|
|
}
|
|
}
|
|
|
|
class BlobDownloadResponse {
|
|
constructor(originalResponse, getter, offset, count, options = {}) {
|
|
this.originalResponse = originalResponse;
|
|
this.blobDownloadStream = new RetriableReadableStream(this.originalResponse.readableStreamBody, getter, offset, count, options);
|
|
}
|
|
get acceptRanges() {
|
|
return this.originalResponse.acceptRanges;
|
|
}
|
|
get cacheControl() {
|
|
return this.originalResponse.cacheControl;
|
|
}
|
|
get contentDisposition() {
|
|
return this.originalResponse.contentDisposition;
|
|
}
|
|
get contentEncoding() {
|
|
return this.originalResponse.contentEncoding;
|
|
}
|
|
get contentLanguage() {
|
|
return this.originalResponse.contentLanguage;
|
|
}
|
|
get blobSequenceNumber() {
|
|
return this.originalResponse.blobSequenceNumber;
|
|
}
|
|
get blobType() {
|
|
return this.originalResponse.blobType;
|
|
}
|
|
get contentLength() {
|
|
return this.originalResponse.contentLength;
|
|
}
|
|
get contentMD5() {
|
|
return this.originalResponse.contentMD5;
|
|
}
|
|
get contentRange() {
|
|
return this.originalResponse.contentRange;
|
|
}
|
|
get contentType() {
|
|
return this.originalResponse.contentType;
|
|
}
|
|
get copyCompletedOn() {
|
|
return this.originalResponse.copyCompletedOn;
|
|
}
|
|
get copyId() {
|
|
return this.originalResponse.copyId;
|
|
}
|
|
get copyProgress() {
|
|
return this.originalResponse.copyProgress;
|
|
}
|
|
get copySource() {
|
|
return this.originalResponse.copySource;
|
|
}
|
|
get copyStatus() {
|
|
return this.originalResponse.copyStatus;
|
|
}
|
|
get copyStatusDescription() {
|
|
return this.originalResponse.copyStatusDescription;
|
|
}
|
|
get leaseDuration() {
|
|
return this.originalResponse.leaseDuration;
|
|
}
|
|
get leaseState() {
|
|
return this.originalResponse.leaseState;
|
|
}
|
|
get leaseStatus() {
|
|
return this.originalResponse.leaseStatus;
|
|
}
|
|
get date() {
|
|
return this.originalResponse.date;
|
|
}
|
|
get blobCommittedBlockCount() {
|
|
return this.originalResponse.blobCommittedBlockCount;
|
|
}
|
|
get etag() {
|
|
return this.originalResponse.etag;
|
|
}
|
|
get tagCount() {
|
|
return this.originalResponse.tagCount;
|
|
}
|
|
get errorCode() {
|
|
return this.originalResponse.errorCode;
|
|
}
|
|
get isServerEncrypted() {
|
|
return this.originalResponse.isServerEncrypted;
|
|
}
|
|
get blobContentMD5() {
|
|
return this.originalResponse.blobContentMD5;
|
|
}
|
|
get lastModified() {
|
|
return this.originalResponse.lastModified;
|
|
}
|
|
get lastAccessed() {
|
|
return this.originalResponse.lastAccessed;
|
|
}
|
|
get createdOn() {
|
|
return this.originalResponse.createdOn;
|
|
}
|
|
get metadata() {
|
|
return this.originalResponse.metadata;
|
|
}
|
|
get requestId() {
|
|
return this.originalResponse.requestId;
|
|
}
|
|
get clientRequestId() {
|
|
return this.originalResponse.clientRequestId;
|
|
}
|
|
get version() {
|
|
return this.originalResponse.version;
|
|
}
|
|
get versionId() {
|
|
return this.originalResponse.versionId;
|
|
}
|
|
get isCurrentVersion() {
|
|
return this.originalResponse.isCurrentVersion;
|
|
}
|
|
get encryptionKeySha256() {
|
|
return this.originalResponse.encryptionKeySha256;
|
|
}
|
|
get contentCrc64() {
|
|
return this.originalResponse.contentCrc64;
|
|
}
|
|
get objectReplicationDestinationPolicyId() {
|
|
return this.originalResponse.objectReplicationDestinationPolicyId;
|
|
}
|
|
get objectReplicationSourceProperties() {
|
|
return this.originalResponse.objectReplicationSourceProperties;
|
|
}
|
|
get isSealed() {
|
|
return this.originalResponse.isSealed;
|
|
}
|
|
get immutabilityPolicyExpiresOn() {
|
|
return this.originalResponse.immutabilityPolicyExpiresOn;
|
|
}
|
|
get immutabilityPolicyMode() {
|
|
return this.originalResponse.immutabilityPolicyMode;
|
|
}
|
|
get legalHold() {
|
|
return this.originalResponse.legalHold;
|
|
}
|
|
get contentAsBlob() {
|
|
return this.originalResponse.blobBody;
|
|
}
|
|
get readableStreamBody() {
|
|
return coreHttp.isNode ? this.blobDownloadStream : undefined;
|
|
}
|
|
get _response() {
|
|
return this.originalResponse._response;
|
|
}
|
|
}
|
|
var AVRO_SYNC_MARKER_SIZE = 16;
|
|
var AVRO_INIT_BYTES = new Uint8Array([79, 98, 106, 1]);
|
|
var AVRO_CODEC_KEY = "avro.codec";
|
|
var AVRO_SCHEMA_KEY = "avro.schema";
|
|
|
|
class AvroParser {
|
|
static async readFixedBytes(stream2, length, options = {}) {
|
|
const bytes = await stream2.read(length, { abortSignal: options.abortSignal });
|
|
if (bytes.length !== length)
|
|
throw new Error("Hit stream end.");
|
|
return bytes;
|
|
}
|
|
static async readByte(stream2, options = {}) {
|
|
const buf = await AvroParser.readFixedBytes(stream2, 1, options);
|
|
return buf[0];
|
|
}
|
|
static async readZigZagLong(stream2, options = {}) {
|
|
let zigZagEncoded = 0;
|
|
let significanceInBit = 0;
|
|
let byte, haveMoreByte, significanceInFloat;
|
|
do {
|
|
byte = await AvroParser.readByte(stream2, options);
|
|
haveMoreByte = byte & 128;
|
|
zigZagEncoded |= (byte & 127) << significanceInBit;
|
|
significanceInBit += 7;
|
|
} while (haveMoreByte && significanceInBit < 28);
|
|
if (haveMoreByte) {
|
|
zigZagEncoded = zigZagEncoded;
|
|
significanceInFloat = 268435456;
|
|
do {
|
|
byte = await AvroParser.readByte(stream2, options);
|
|
zigZagEncoded += (byte & 127) * significanceInFloat;
|
|
significanceInFloat *= 128;
|
|
} while (byte & 128);
|
|
const res = (zigZagEncoded % 2 ? -(zigZagEncoded + 1) : zigZagEncoded) / 2;
|
|
if (res < Number.MIN_SAFE_INTEGER || res > Number.MAX_SAFE_INTEGER)
|
|
throw new Error("Integer overflow.");
|
|
return res;
|
|
}
|
|
return zigZagEncoded >> 1 ^ -(zigZagEncoded & 1);
|
|
}
|
|
static async readLong(stream2, options = {}) {
|
|
return AvroParser.readZigZagLong(stream2, options);
|
|
}
|
|
static async readInt(stream2, options = {}) {
|
|
return AvroParser.readZigZagLong(stream2, options);
|
|
}
|
|
static async readNull() {
|
|
return null;
|
|
}
|
|
static async readBoolean(stream2, options = {}) {
|
|
const b = await AvroParser.readByte(stream2, options);
|
|
if (b === 1)
|
|
return true;
|
|
else if (b === 0)
|
|
return false;
|
|
else
|
|
throw new Error("Byte was not a boolean.");
|
|
}
|
|
static async readFloat(stream2, options = {}) {
|
|
const u8arr = await AvroParser.readFixedBytes(stream2, 4, options);
|
|
const view = new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength);
|
|
return view.getFloat32(0, true);
|
|
}
|
|
static async readDouble(stream2, options = {}) {
|
|
const u8arr = await AvroParser.readFixedBytes(stream2, 8, options);
|
|
const view = new DataView(u8arr.buffer, u8arr.byteOffset, u8arr.byteLength);
|
|
return view.getFloat64(0, true);
|
|
}
|
|
static async readBytes(stream2, options = {}) {
|
|
const size = await AvroParser.readLong(stream2, options);
|
|
if (size < 0)
|
|
throw new Error("Bytes size was negative.");
|
|
return stream2.read(size, { abortSignal: options.abortSignal });
|
|
}
|
|
static async readString(stream2, options = {}) {
|
|
const u8arr = await AvroParser.readBytes(stream2, options);
|
|
const utf8decoder = new TextDecoder;
|
|
return utf8decoder.decode(u8arr);
|
|
}
|
|
static async readMapPair(stream2, readItemMethod, options = {}) {
|
|
const key = await AvroParser.readString(stream2, options);
|
|
const value = await readItemMethod(stream2, options);
|
|
return { key, value };
|
|
}
|
|
static async readMap(stream2, readItemMethod, options = {}) {
|
|
const readPairMethod = (s, opts = {}) => {
|
|
return AvroParser.readMapPair(s, readItemMethod, opts);
|
|
};
|
|
const pairs = await AvroParser.readArray(stream2, readPairMethod, options);
|
|
const dict = {};
|
|
for (const pair of pairs)
|
|
dict[pair.key] = pair.value;
|
|
return dict;
|
|
}
|
|
static async readArray(stream2, readItemMethod, options = {}) {
|
|
const items = [];
|
|
for (let count = await AvroParser.readLong(stream2, options);count !== 0; count = await AvroParser.readLong(stream2, options)) {
|
|
if (count < 0) {
|
|
await AvroParser.readLong(stream2, options);
|
|
count = -count;
|
|
}
|
|
while (count--) {
|
|
const item = await readItemMethod(stream2, options);
|
|
items.push(item);
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
}
|
|
var AvroComplex;
|
|
(function(AvroComplex2) {
|
|
AvroComplex2["RECORD"] = "record";
|
|
AvroComplex2["ENUM"] = "enum";
|
|
AvroComplex2["ARRAY"] = "array";
|
|
AvroComplex2["MAP"] = "map";
|
|
AvroComplex2["UNION"] = "union";
|
|
AvroComplex2["FIXED"] = "fixed";
|
|
})(AvroComplex || (AvroComplex = {}));
|
|
var AvroPrimitive;
|
|
(function(AvroPrimitive2) {
|
|
AvroPrimitive2["NULL"] = "null";
|
|
AvroPrimitive2["BOOLEAN"] = "boolean";
|
|
AvroPrimitive2["INT"] = "int";
|
|
AvroPrimitive2["LONG"] = "long";
|
|
AvroPrimitive2["FLOAT"] = "float";
|
|
AvroPrimitive2["DOUBLE"] = "double";
|
|
AvroPrimitive2["BYTES"] = "bytes";
|
|
AvroPrimitive2["STRING"] = "string";
|
|
})(AvroPrimitive || (AvroPrimitive = {}));
|
|
|
|
class AvroType {
|
|
static fromSchema(schema) {
|
|
if (typeof schema === "string")
|
|
return AvroType.fromStringSchema(schema);
|
|
else if (Array.isArray(schema))
|
|
return AvroType.fromArraySchema(schema);
|
|
else
|
|
return AvroType.fromObjectSchema(schema);
|
|
}
|
|
static fromStringSchema(schema) {
|
|
switch (schema) {
|
|
case AvroPrimitive.NULL:
|
|
case AvroPrimitive.BOOLEAN:
|
|
case AvroPrimitive.INT:
|
|
case AvroPrimitive.LONG:
|
|
case AvroPrimitive.FLOAT:
|
|
case AvroPrimitive.DOUBLE:
|
|
case AvroPrimitive.BYTES:
|
|
case AvroPrimitive.STRING:
|
|
return new AvroPrimitiveType(schema);
|
|
default:
|
|
throw new Error(`Unexpected Avro type ${schema}`);
|
|
}
|
|
}
|
|
static fromArraySchema(schema) {
|
|
return new AvroUnionType(schema.map(AvroType.fromSchema));
|
|
}
|
|
static fromObjectSchema(schema) {
|
|
const type = schema.type;
|
|
try {
|
|
return AvroType.fromStringSchema(type);
|
|
} catch (err) {
|
|
}
|
|
switch (type) {
|
|
case AvroComplex.RECORD:
|
|
if (schema.aliases)
|
|
throw new Error(`aliases currently is not supported, schema: ${schema}`);
|
|
if (!schema.name)
|
|
throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
|
|
const fields = {};
|
|
if (!schema.fields)
|
|
throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
|
|
for (const field of schema.fields)
|
|
fields[field.name] = AvroType.fromSchema(field.type);
|
|
return new AvroRecordType(fields, schema.name);
|
|
case AvroComplex.ENUM:
|
|
if (schema.aliases)
|
|
throw new Error(`aliases currently is not supported, schema: ${schema}`);
|
|
if (!schema.symbols)
|
|
throw new Error(`Required attribute 'symbols' doesn't exist on schema: ${schema}`);
|
|
return new AvroEnumType(schema.symbols);
|
|
case AvroComplex.MAP:
|
|
if (!schema.values)
|
|
throw new Error(`Required attribute 'values' doesn't exist on schema: ${schema}`);
|
|
return new AvroMapType(AvroType.fromSchema(schema.values));
|
|
case AvroComplex.ARRAY:
|
|
case AvroComplex.FIXED:
|
|
default:
|
|
throw new Error(`Unexpected Avro type ${type} in ${schema}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
class AvroPrimitiveType extends AvroType {
|
|
constructor(primitive) {
|
|
super();
|
|
this._primitive = primitive;
|
|
}
|
|
read(stream2, options = {}) {
|
|
switch (this._primitive) {
|
|
case AvroPrimitive.NULL:
|
|
return AvroParser.readNull();
|
|
case AvroPrimitive.BOOLEAN:
|
|
return AvroParser.readBoolean(stream2, options);
|
|
case AvroPrimitive.INT:
|
|
return AvroParser.readInt(stream2, options);
|
|
case AvroPrimitive.LONG:
|
|
return AvroParser.readLong(stream2, options);
|
|
case AvroPrimitive.FLOAT:
|
|
return AvroParser.readFloat(stream2, options);
|
|
case AvroPrimitive.DOUBLE:
|
|
return AvroParser.readDouble(stream2, options);
|
|
case AvroPrimitive.BYTES:
|
|
return AvroParser.readBytes(stream2, options);
|
|
case AvroPrimitive.STRING:
|
|
return AvroParser.readString(stream2, options);
|
|
default:
|
|
throw new Error("Unknown Avro Primitive");
|
|
}
|
|
}
|
|
}
|
|
|
|
class AvroEnumType extends AvroType {
|
|
constructor(symbols) {
|
|
super();
|
|
this._symbols = symbols;
|
|
}
|
|
async read(stream2, options = {}) {
|
|
const value = await AvroParser.readInt(stream2, options);
|
|
return this._symbols[value];
|
|
}
|
|
}
|
|
|
|
class AvroUnionType extends AvroType {
|
|
constructor(types) {
|
|
super();
|
|
this._types = types;
|
|
}
|
|
async read(stream2, options = {}) {
|
|
const typeIndex = await AvroParser.readInt(stream2, options);
|
|
return this._types[typeIndex].read(stream2, options);
|
|
}
|
|
}
|
|
|
|
class AvroMapType extends AvroType {
|
|
constructor(itemType) {
|
|
super();
|
|
this._itemType = itemType;
|
|
}
|
|
read(stream2, options = {}) {
|
|
const readItemMethod = (s, opts) => {
|
|
return this._itemType.read(s, opts);
|
|
};
|
|
return AvroParser.readMap(stream2, readItemMethod, options);
|
|
}
|
|
}
|
|
|
|
class AvroRecordType extends AvroType {
|
|
constructor(fields, name) {
|
|
super();
|
|
this._fields = fields;
|
|
this._name = name;
|
|
}
|
|
async read(stream2, options = {}) {
|
|
const record = {};
|
|
record["$schema"] = this._name;
|
|
for (const key in this._fields)
|
|
if (Object.prototype.hasOwnProperty.call(this._fields, key))
|
|
record[key] = await this._fields[key].read(stream2, options);
|
|
return record;
|
|
}
|
|
}
|
|
|
|
class AvroReader {
|
|
constructor(dataStream, headerStream, currentBlockOffset, indexWithinCurrentBlock) {
|
|
this._dataStream = dataStream;
|
|
this._headerStream = headerStream || dataStream;
|
|
this._initialized = false;
|
|
this._blockOffset = currentBlockOffset || 0;
|
|
this._objectIndex = indexWithinCurrentBlock || 0;
|
|
this._initialBlockOffset = currentBlockOffset || 0;
|
|
}
|
|
get blockOffset() {
|
|
return this._blockOffset;
|
|
}
|
|
get objectIndex() {
|
|
return this._objectIndex;
|
|
}
|
|
async initialize(options = {}) {
|
|
const header = await AvroParser.readFixedBytes(this._headerStream, AVRO_INIT_BYTES.length, {
|
|
abortSignal: options.abortSignal
|
|
});
|
|
if (!arraysEqual(header, AVRO_INIT_BYTES))
|
|
throw new Error("Stream is not an Avro file.");
|
|
this._metadata = await AvroParser.readMap(this._headerStream, AvroParser.readString, {
|
|
abortSignal: options.abortSignal
|
|
});
|
|
const codec = this._metadata[AVRO_CODEC_KEY];
|
|
if (!(codec === undefined || codec === null || codec === "null"))
|
|
throw new Error("Codecs are not supported");
|
|
this._syncMarker = await AvroParser.readFixedBytes(this._headerStream, AVRO_SYNC_MARKER_SIZE, {
|
|
abortSignal: options.abortSignal
|
|
});
|
|
const schema = JSON.parse(this._metadata[AVRO_SCHEMA_KEY]);
|
|
this._itemType = AvroType.fromSchema(schema);
|
|
if (this._blockOffset === 0)
|
|
this._blockOffset = this._initialBlockOffset + this._dataStream.position;
|
|
this._itemsRemainingInBlock = await AvroParser.readLong(this._dataStream, {
|
|
abortSignal: options.abortSignal
|
|
});
|
|
await AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal });
|
|
this._initialized = true;
|
|
if (this._objectIndex && this._objectIndex > 0)
|
|
for (let i = 0;i < this._objectIndex; i++) {
|
|
await this._itemType.read(this._dataStream, { abortSignal: options.abortSignal });
|
|
this._itemsRemainingInBlock--;
|
|
}
|
|
}
|
|
hasNext() {
|
|
return !this._initialized || this._itemsRemainingInBlock > 0;
|
|
}
|
|
parseObjects(options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* parseObjects_1() {
|
|
if (!this._initialized)
|
|
yield tslib.__await(this.initialize(options));
|
|
while (this.hasNext()) {
|
|
const result = yield tslib.__await(this._itemType.read(this._dataStream, {
|
|
abortSignal: options.abortSignal
|
|
}));
|
|
this._itemsRemainingInBlock--;
|
|
this._objectIndex++;
|
|
if (this._itemsRemainingInBlock === 0) {
|
|
const marker2 = yield tslib.__await(AvroParser.readFixedBytes(this._dataStream, AVRO_SYNC_MARKER_SIZE, {
|
|
abortSignal: options.abortSignal
|
|
}));
|
|
this._blockOffset = this._initialBlockOffset + this._dataStream.position;
|
|
this._objectIndex = 0;
|
|
if (!arraysEqual(this._syncMarker, marker2))
|
|
throw new Error("Stream is not a valid Avro file.");
|
|
try {
|
|
this._itemsRemainingInBlock = yield tslib.__await(AvroParser.readLong(this._dataStream, {
|
|
abortSignal: options.abortSignal
|
|
}));
|
|
} catch (err) {
|
|
this._itemsRemainingInBlock = 0;
|
|
}
|
|
if (this._itemsRemainingInBlock > 0)
|
|
yield tslib.__await(AvroParser.readLong(this._dataStream, { abortSignal: options.abortSignal }));
|
|
}
|
|
yield yield tslib.__await(result);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
class AvroReadable {
|
|
}
|
|
var ABORT_ERROR = new abortController.AbortError("Reading from the avro stream was aborted.");
|
|
|
|
class AvroReadableFromStream extends AvroReadable {
|
|
constructor(readable) {
|
|
super();
|
|
this._readable = readable;
|
|
this._position = 0;
|
|
}
|
|
toUint8Array(data) {
|
|
if (typeof data === "string")
|
|
return Buffer.from(data);
|
|
return data;
|
|
}
|
|
get position() {
|
|
return this._position;
|
|
}
|
|
async read(size, options = {}) {
|
|
var _a;
|
|
if ((_a = options.abortSignal) === null || _a === undefined ? undefined : _a.aborted)
|
|
throw ABORT_ERROR;
|
|
if (size < 0)
|
|
throw new Error(`size parameter should be positive: ${size}`);
|
|
if (size === 0)
|
|
return new Uint8Array;
|
|
if (!this._readable.readable)
|
|
throw new Error("Stream no longer readable.");
|
|
const chunk = this._readable.read(size);
|
|
if (chunk) {
|
|
this._position += chunk.length;
|
|
return this.toUint8Array(chunk);
|
|
} else
|
|
return new Promise((resolve, reject) => {
|
|
const cleanUp = () => {
|
|
this._readable.removeListener("readable", readableCallback);
|
|
this._readable.removeListener("error", rejectCallback);
|
|
this._readable.removeListener("end", rejectCallback);
|
|
this._readable.removeListener("close", rejectCallback);
|
|
if (options.abortSignal)
|
|
options.abortSignal.removeEventListener("abort", abortHandler);
|
|
};
|
|
const readableCallback = () => {
|
|
const callbackChunk = this._readable.read(size);
|
|
if (callbackChunk) {
|
|
this._position += callbackChunk.length;
|
|
cleanUp();
|
|
resolve(this.toUint8Array(callbackChunk));
|
|
}
|
|
};
|
|
const rejectCallback = () => {
|
|
cleanUp();
|
|
reject();
|
|
};
|
|
const abortHandler = () => {
|
|
cleanUp();
|
|
reject(ABORT_ERROR);
|
|
};
|
|
this._readable.on("readable", readableCallback);
|
|
this._readable.once("error", rejectCallback);
|
|
this._readable.once("end", rejectCallback);
|
|
this._readable.once("close", rejectCallback);
|
|
if (options.abortSignal)
|
|
options.abortSignal.addEventListener("abort", abortHandler);
|
|
});
|
|
}
|
|
}
|
|
|
|
class BlobQuickQueryStream extends stream.Readable {
|
|
constructor(source, options = {}) {
|
|
super();
|
|
this.avroPaused = true;
|
|
this.source = source;
|
|
this.onProgress = options.onProgress;
|
|
this.onError = options.onError;
|
|
this.avroReader = new AvroReader(new AvroReadableFromStream(this.source));
|
|
this.avroIter = this.avroReader.parseObjects({ abortSignal: options.abortSignal });
|
|
}
|
|
_read() {
|
|
if (this.avroPaused)
|
|
this.readInternal().catch((err) => {
|
|
this.emit("error", err);
|
|
});
|
|
}
|
|
async readInternal() {
|
|
this.avroPaused = false;
|
|
let avroNext;
|
|
do {
|
|
avroNext = await this.avroIter.next();
|
|
if (avroNext.done)
|
|
break;
|
|
const obj = avroNext.value;
|
|
const schema = obj.$schema;
|
|
if (typeof schema !== "string")
|
|
throw Error("Missing schema in avro record.");
|
|
switch (schema) {
|
|
case "com.microsoft.azure.storage.queryBlobContents.resultData":
|
|
{
|
|
const data = obj.data;
|
|
if (data instanceof Uint8Array === false)
|
|
throw Error("Invalid data in avro result record.");
|
|
if (!this.push(Buffer.from(data)))
|
|
this.avroPaused = true;
|
|
}
|
|
break;
|
|
case "com.microsoft.azure.storage.queryBlobContents.progress":
|
|
{
|
|
const bytesScanned = obj.bytesScanned;
|
|
if (typeof bytesScanned !== "number")
|
|
throw Error("Invalid bytesScanned in avro progress record.");
|
|
if (this.onProgress)
|
|
this.onProgress({ loadedBytes: bytesScanned });
|
|
}
|
|
break;
|
|
case "com.microsoft.azure.storage.queryBlobContents.end":
|
|
if (this.onProgress) {
|
|
const totalBytes = obj.totalBytes;
|
|
if (typeof totalBytes !== "number")
|
|
throw Error("Invalid totalBytes in avro end record.");
|
|
this.onProgress({ loadedBytes: totalBytes });
|
|
}
|
|
this.push(null);
|
|
break;
|
|
case "com.microsoft.azure.storage.queryBlobContents.error":
|
|
if (this.onError) {
|
|
const fatal = obj.fatal;
|
|
if (typeof fatal !== "boolean")
|
|
throw Error("Invalid fatal in avro error record.");
|
|
const name = obj.name;
|
|
if (typeof name !== "string")
|
|
throw Error("Invalid name in avro error record.");
|
|
const description = obj.description;
|
|
if (typeof description !== "string")
|
|
throw Error("Invalid description in avro error record.");
|
|
const position = obj.position;
|
|
if (typeof position !== "number")
|
|
throw Error("Invalid position in avro error record.");
|
|
this.onError({
|
|
position,
|
|
name,
|
|
isFatal: fatal,
|
|
description
|
|
});
|
|
}
|
|
break;
|
|
default:
|
|
throw Error(`Unknown schema ${schema} in avro progress record.`);
|
|
}
|
|
} while (!avroNext.done && !this.avroPaused);
|
|
}
|
|
}
|
|
|
|
class BlobQueryResponse {
|
|
constructor(originalResponse, options = {}) {
|
|
this.originalResponse = originalResponse;
|
|
this.blobDownloadStream = new BlobQuickQueryStream(this.originalResponse.readableStreamBody, options);
|
|
}
|
|
get acceptRanges() {
|
|
return this.originalResponse.acceptRanges;
|
|
}
|
|
get cacheControl() {
|
|
return this.originalResponse.cacheControl;
|
|
}
|
|
get contentDisposition() {
|
|
return this.originalResponse.contentDisposition;
|
|
}
|
|
get contentEncoding() {
|
|
return this.originalResponse.contentEncoding;
|
|
}
|
|
get contentLanguage() {
|
|
return this.originalResponse.contentLanguage;
|
|
}
|
|
get blobSequenceNumber() {
|
|
return this.originalResponse.blobSequenceNumber;
|
|
}
|
|
get blobType() {
|
|
return this.originalResponse.blobType;
|
|
}
|
|
get contentLength() {
|
|
return this.originalResponse.contentLength;
|
|
}
|
|
get contentMD5() {
|
|
return this.originalResponse.contentMD5;
|
|
}
|
|
get contentRange() {
|
|
return this.originalResponse.contentRange;
|
|
}
|
|
get contentType() {
|
|
return this.originalResponse.contentType;
|
|
}
|
|
get copyCompletedOn() {
|
|
return;
|
|
}
|
|
get copyId() {
|
|
return this.originalResponse.copyId;
|
|
}
|
|
get copyProgress() {
|
|
return this.originalResponse.copyProgress;
|
|
}
|
|
get copySource() {
|
|
return this.originalResponse.copySource;
|
|
}
|
|
get copyStatus() {
|
|
return this.originalResponse.copyStatus;
|
|
}
|
|
get copyStatusDescription() {
|
|
return this.originalResponse.copyStatusDescription;
|
|
}
|
|
get leaseDuration() {
|
|
return this.originalResponse.leaseDuration;
|
|
}
|
|
get leaseState() {
|
|
return this.originalResponse.leaseState;
|
|
}
|
|
get leaseStatus() {
|
|
return this.originalResponse.leaseStatus;
|
|
}
|
|
get date() {
|
|
return this.originalResponse.date;
|
|
}
|
|
get blobCommittedBlockCount() {
|
|
return this.originalResponse.blobCommittedBlockCount;
|
|
}
|
|
get etag() {
|
|
return this.originalResponse.etag;
|
|
}
|
|
get errorCode() {
|
|
return this.originalResponse.errorCode;
|
|
}
|
|
get isServerEncrypted() {
|
|
return this.originalResponse.isServerEncrypted;
|
|
}
|
|
get blobContentMD5() {
|
|
return this.originalResponse.blobContentMD5;
|
|
}
|
|
get lastModified() {
|
|
return this.originalResponse.lastModified;
|
|
}
|
|
get metadata() {
|
|
return this.originalResponse.metadata;
|
|
}
|
|
get requestId() {
|
|
return this.originalResponse.requestId;
|
|
}
|
|
get clientRequestId() {
|
|
return this.originalResponse.clientRequestId;
|
|
}
|
|
get version() {
|
|
return this.originalResponse.version;
|
|
}
|
|
get encryptionKeySha256() {
|
|
return this.originalResponse.encryptionKeySha256;
|
|
}
|
|
get contentCrc64() {
|
|
return this.originalResponse.contentCrc64;
|
|
}
|
|
get blobBody() {
|
|
return;
|
|
}
|
|
get readableStreamBody() {
|
|
return coreHttp.isNode ? this.blobDownloadStream : undefined;
|
|
}
|
|
get _response() {
|
|
return this.originalResponse._response;
|
|
}
|
|
}
|
|
exports.BlockBlobTier = undefined;
|
|
(function(BlockBlobTier) {
|
|
BlockBlobTier["Hot"] = "Hot";
|
|
BlockBlobTier["Cool"] = "Cool";
|
|
BlockBlobTier["Cold"] = "Cold";
|
|
BlockBlobTier["Archive"] = "Archive";
|
|
})(exports.BlockBlobTier || (exports.BlockBlobTier = {}));
|
|
exports.PremiumPageBlobTier = undefined;
|
|
(function(PremiumPageBlobTier) {
|
|
PremiumPageBlobTier["P4"] = "P4";
|
|
PremiumPageBlobTier["P6"] = "P6";
|
|
PremiumPageBlobTier["P10"] = "P10";
|
|
PremiumPageBlobTier["P15"] = "P15";
|
|
PremiumPageBlobTier["P20"] = "P20";
|
|
PremiumPageBlobTier["P30"] = "P30";
|
|
PremiumPageBlobTier["P40"] = "P40";
|
|
PremiumPageBlobTier["P50"] = "P50";
|
|
PremiumPageBlobTier["P60"] = "P60";
|
|
PremiumPageBlobTier["P70"] = "P70";
|
|
PremiumPageBlobTier["P80"] = "P80";
|
|
})(exports.PremiumPageBlobTier || (exports.PremiumPageBlobTier = {}));
|
|
exports.StorageBlobAudience = undefined;
|
|
(function(StorageBlobAudience) {
|
|
StorageBlobAudience["StorageOAuthScopes"] = "https://storage.azure.com/.default";
|
|
StorageBlobAudience["DiskComputeOAuthScopes"] = "https://disk.compute.azure.com/.default";
|
|
})(exports.StorageBlobAudience || (exports.StorageBlobAudience = {}));
|
|
|
|
class BlobBeginCopyFromUrlPoller extends coreLro.Poller {
|
|
constructor(options) {
|
|
const { blobClient, copySource: copySource2, intervalInMs = 15000, onProgress, resumeFrom, startCopyFromURLOptions } = options;
|
|
let state;
|
|
if (resumeFrom)
|
|
state = JSON.parse(resumeFrom).state;
|
|
const operation = makeBlobBeginCopyFromURLPollOperation(Object.assign(Object.assign({}, state), {
|
|
blobClient,
|
|
copySource: copySource2,
|
|
startCopyFromURLOptions
|
|
}));
|
|
super(operation);
|
|
if (typeof onProgress === "function")
|
|
this.onProgress(onProgress);
|
|
this.intervalInMs = intervalInMs;
|
|
}
|
|
delay() {
|
|
return coreHttp.delay(this.intervalInMs);
|
|
}
|
|
}
|
|
var cancel = async function cancel(options = {}) {
|
|
const state = this.state;
|
|
const { copyId: copyId2 } = state;
|
|
if (state.isCompleted)
|
|
return makeBlobBeginCopyFromURLPollOperation(state);
|
|
if (!copyId2) {
|
|
state.isCancelled = true;
|
|
return makeBlobBeginCopyFromURLPollOperation(state);
|
|
}
|
|
await state.blobClient.abortCopyFromURL(copyId2, {
|
|
abortSignal: options.abortSignal
|
|
});
|
|
state.isCancelled = true;
|
|
return makeBlobBeginCopyFromURLPollOperation(state);
|
|
};
|
|
var update = async function update(options = {}) {
|
|
const state = this.state;
|
|
const { blobClient, copySource: copySource2, startCopyFromURLOptions } = state;
|
|
if (!state.isStarted) {
|
|
state.isStarted = true;
|
|
const result = await blobClient.startCopyFromURL(copySource2, startCopyFromURLOptions);
|
|
state.copyId = result.copyId;
|
|
if (result.copyStatus === "success") {
|
|
state.result = result;
|
|
state.isCompleted = true;
|
|
}
|
|
} else if (!state.isCompleted)
|
|
try {
|
|
const result = await state.blobClient.getProperties({ abortSignal: options.abortSignal });
|
|
const { copyStatus, copyProgress } = result;
|
|
const prevCopyProgress = state.copyProgress;
|
|
if (copyProgress)
|
|
state.copyProgress = copyProgress;
|
|
if (copyStatus === "pending" && copyProgress !== prevCopyProgress && typeof options.fireProgress === "function")
|
|
options.fireProgress(state);
|
|
else if (copyStatus === "success") {
|
|
state.result = result;
|
|
state.isCompleted = true;
|
|
} else if (copyStatus === "failed") {
|
|
state.error = new Error(`Blob copy failed with reason: "${result.copyStatusDescription || "unknown"}"`);
|
|
state.isCompleted = true;
|
|
}
|
|
} catch (err) {
|
|
state.error = err;
|
|
state.isCompleted = true;
|
|
}
|
|
return makeBlobBeginCopyFromURLPollOperation(state);
|
|
};
|
|
var toString = function toString() {
|
|
return JSON.stringify({ state: this.state }, (key, value) => {
|
|
if (key === "blobClient")
|
|
return;
|
|
return value;
|
|
});
|
|
};
|
|
var BatchStates;
|
|
(function(BatchStates2) {
|
|
BatchStates2[BatchStates2["Good"] = 0] = "Good";
|
|
BatchStates2[BatchStates2["Error"] = 1] = "Error";
|
|
})(BatchStates || (BatchStates = {}));
|
|
|
|
class Batch {
|
|
constructor(concurrency = 5) {
|
|
this.actives = 0;
|
|
this.completed = 0;
|
|
this.offset = 0;
|
|
this.operations = [];
|
|
this.state = BatchStates.Good;
|
|
if (concurrency < 1)
|
|
throw new RangeError("concurrency must be larger than 0");
|
|
this.concurrency = concurrency;
|
|
this.emitter = new events.EventEmitter;
|
|
}
|
|
addOperation(operation) {
|
|
this.operations.push(async () => {
|
|
try {
|
|
this.actives++;
|
|
await operation();
|
|
this.actives--;
|
|
this.completed++;
|
|
this.parallelExecute();
|
|
} catch (error) {
|
|
this.emitter.emit("error", error);
|
|
}
|
|
});
|
|
}
|
|
async do() {
|
|
if (this.operations.length === 0)
|
|
return Promise.resolve();
|
|
this.parallelExecute();
|
|
return new Promise((resolve, reject) => {
|
|
this.emitter.on("finish", resolve);
|
|
this.emitter.on("error", (error) => {
|
|
this.state = BatchStates.Error;
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
nextOperation() {
|
|
if (this.offset < this.operations.length)
|
|
return this.operations[this.offset++];
|
|
return null;
|
|
}
|
|
parallelExecute() {
|
|
if (this.state === BatchStates.Error)
|
|
return;
|
|
if (this.completed >= this.operations.length) {
|
|
this.emitter.emit("finish");
|
|
return;
|
|
}
|
|
while (this.actives < this.concurrency) {
|
|
const operation = this.nextOperation();
|
|
if (operation)
|
|
operation();
|
|
else
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
class BuffersStream extends stream.Readable {
|
|
constructor(buffers, byteLength, options) {
|
|
super(options);
|
|
this.buffers = buffers;
|
|
this.byteLength = byteLength;
|
|
this.byteOffsetInCurrentBuffer = 0;
|
|
this.bufferIndex = 0;
|
|
this.pushedBytesLength = 0;
|
|
let buffersLength = 0;
|
|
for (const buf of this.buffers)
|
|
buffersLength += buf.byteLength;
|
|
if (buffersLength < this.byteLength)
|
|
throw new Error("Data size shouldn't be larger than the total length of buffers.");
|
|
}
|
|
_read(size) {
|
|
if (this.pushedBytesLength >= this.byteLength)
|
|
this.push(null);
|
|
if (!size)
|
|
size = this.readableHighWaterMark;
|
|
const outBuffers = [];
|
|
let i = 0;
|
|
while (i < size && this.pushedBytesLength < this.byteLength) {
|
|
const remainingDataInAllBuffers = this.byteLength - this.pushedBytesLength;
|
|
const remainingCapacityInThisBuffer = this.buffers[this.bufferIndex].byteLength - this.byteOffsetInCurrentBuffer;
|
|
const remaining = Math.min(remainingCapacityInThisBuffer, remainingDataInAllBuffers);
|
|
if (remaining > size - i) {
|
|
const end = this.byteOffsetInCurrentBuffer + size - i;
|
|
outBuffers.push(this.buffers[this.bufferIndex].slice(this.byteOffsetInCurrentBuffer, end));
|
|
this.pushedBytesLength += size - i;
|
|
this.byteOffsetInCurrentBuffer = end;
|
|
i = size;
|
|
break;
|
|
} else {
|
|
const end = this.byteOffsetInCurrentBuffer + remaining;
|
|
outBuffers.push(this.buffers[this.bufferIndex].slice(this.byteOffsetInCurrentBuffer, end));
|
|
if (remaining === remainingCapacityInThisBuffer) {
|
|
this.byteOffsetInCurrentBuffer = 0;
|
|
this.bufferIndex++;
|
|
} else
|
|
this.byteOffsetInCurrentBuffer = end;
|
|
this.pushedBytesLength += remaining;
|
|
i += remaining;
|
|
}
|
|
}
|
|
if (outBuffers.length > 1)
|
|
this.push(Buffer.concat(outBuffers));
|
|
else if (outBuffers.length === 1)
|
|
this.push(outBuffers[0]);
|
|
}
|
|
}
|
|
var maxBufferLength = __require("buffer").constants.MAX_LENGTH;
|
|
|
|
class PooledBuffer {
|
|
constructor(capacity, buffers, totalLength) {
|
|
this.buffers = [];
|
|
this.capacity = capacity;
|
|
this._size = 0;
|
|
const bufferNum = Math.ceil(capacity / maxBufferLength);
|
|
for (let i = 0;i < bufferNum; i++) {
|
|
let len = i === bufferNum - 1 ? capacity % maxBufferLength : maxBufferLength;
|
|
if (len === 0)
|
|
len = maxBufferLength;
|
|
this.buffers.push(Buffer.allocUnsafe(len));
|
|
}
|
|
if (buffers)
|
|
this.fill(buffers, totalLength);
|
|
}
|
|
get size() {
|
|
return this._size;
|
|
}
|
|
fill(buffers, totalLength) {
|
|
this._size = Math.min(this.capacity, totalLength);
|
|
let i = 0, j = 0, targetOffset = 0, sourceOffset = 0, totalCopiedNum = 0;
|
|
while (totalCopiedNum < this._size) {
|
|
const source = buffers[i];
|
|
const target = this.buffers[j];
|
|
const copiedNum = source.copy(target, targetOffset, sourceOffset);
|
|
totalCopiedNum += copiedNum;
|
|
sourceOffset += copiedNum;
|
|
targetOffset += copiedNum;
|
|
if (sourceOffset === source.length) {
|
|
i++;
|
|
sourceOffset = 0;
|
|
}
|
|
if (targetOffset === target.length) {
|
|
j++;
|
|
targetOffset = 0;
|
|
}
|
|
}
|
|
buffers.splice(0, i);
|
|
if (buffers.length > 0)
|
|
buffers[0] = buffers[0].slice(sourceOffset);
|
|
}
|
|
getReadableStream() {
|
|
return new BuffersStream(this.buffers, this.size);
|
|
}
|
|
}
|
|
|
|
class BufferScheduler {
|
|
constructor(readable, bufferSize, maxBuffers, outgoingHandler, concurrency, encoding) {
|
|
this.emitter = new events.EventEmitter;
|
|
this.offset = 0;
|
|
this.isStreamEnd = false;
|
|
this.isError = false;
|
|
this.executingOutgoingHandlers = 0;
|
|
this.numBuffers = 0;
|
|
this.unresolvedDataArray = [];
|
|
this.unresolvedLength = 0;
|
|
this.incoming = [];
|
|
this.outgoing = [];
|
|
if (bufferSize <= 0)
|
|
throw new RangeError(`bufferSize must be larger than 0, current is ${bufferSize}`);
|
|
if (maxBuffers <= 0)
|
|
throw new RangeError(`maxBuffers must be larger than 0, current is ${maxBuffers}`);
|
|
if (concurrency <= 0)
|
|
throw new RangeError(`concurrency must be larger than 0, current is ${concurrency}`);
|
|
this.bufferSize = bufferSize;
|
|
this.maxBuffers = maxBuffers;
|
|
this.readable = readable;
|
|
this.outgoingHandler = outgoingHandler;
|
|
this.concurrency = concurrency;
|
|
this.encoding = encoding;
|
|
}
|
|
async do() {
|
|
return new Promise((resolve, reject) => {
|
|
this.readable.on("data", (data) => {
|
|
data = typeof data === "string" ? Buffer.from(data, this.encoding) : data;
|
|
this.appendUnresolvedData(data);
|
|
if (!this.resolveData())
|
|
this.readable.pause();
|
|
});
|
|
this.readable.on("error", (err) => {
|
|
this.emitter.emit("error", err);
|
|
});
|
|
this.readable.on("end", () => {
|
|
this.isStreamEnd = true;
|
|
this.emitter.emit("checkEnd");
|
|
});
|
|
this.emitter.on("error", (err) => {
|
|
this.isError = true;
|
|
this.readable.pause();
|
|
reject(err);
|
|
});
|
|
this.emitter.on("checkEnd", () => {
|
|
if (this.outgoing.length > 0) {
|
|
this.triggerOutgoingHandlers();
|
|
return;
|
|
}
|
|
if (this.isStreamEnd && this.executingOutgoingHandlers === 0)
|
|
if (this.unresolvedLength > 0 && this.unresolvedLength < this.bufferSize) {
|
|
const buffer = this.shiftBufferFromUnresolvedDataArray();
|
|
this.outgoingHandler(() => buffer.getReadableStream(), buffer.size, this.offset).then(resolve).catch(reject);
|
|
} else if (this.unresolvedLength >= this.bufferSize)
|
|
return;
|
|
else
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
appendUnresolvedData(data) {
|
|
this.unresolvedDataArray.push(data);
|
|
this.unresolvedLength += data.length;
|
|
}
|
|
shiftBufferFromUnresolvedDataArray(buffer) {
|
|
if (!buffer)
|
|
buffer = new PooledBuffer(this.bufferSize, this.unresolvedDataArray, this.unresolvedLength);
|
|
else
|
|
buffer.fill(this.unresolvedDataArray, this.unresolvedLength);
|
|
this.unresolvedLength -= buffer.size;
|
|
return buffer;
|
|
}
|
|
resolveData() {
|
|
while (this.unresolvedLength >= this.bufferSize) {
|
|
let buffer;
|
|
if (this.incoming.length > 0) {
|
|
buffer = this.incoming.shift();
|
|
this.shiftBufferFromUnresolvedDataArray(buffer);
|
|
} else if (this.numBuffers < this.maxBuffers) {
|
|
buffer = this.shiftBufferFromUnresolvedDataArray();
|
|
this.numBuffers++;
|
|
} else
|
|
return false;
|
|
this.outgoing.push(buffer);
|
|
this.triggerOutgoingHandlers();
|
|
}
|
|
return true;
|
|
}
|
|
async triggerOutgoingHandlers() {
|
|
let buffer;
|
|
do {
|
|
if (this.executingOutgoingHandlers >= this.concurrency)
|
|
return;
|
|
buffer = this.outgoing.shift();
|
|
if (buffer)
|
|
this.triggerOutgoingHandler(buffer);
|
|
} while (buffer);
|
|
}
|
|
async triggerOutgoingHandler(buffer) {
|
|
const bufferLength = buffer.size;
|
|
this.executingOutgoingHandlers++;
|
|
this.offset += bufferLength;
|
|
try {
|
|
await this.outgoingHandler(() => buffer.getReadableStream(), bufferLength, this.offset - bufferLength);
|
|
} catch (err) {
|
|
this.emitter.emit("error", err);
|
|
return;
|
|
}
|
|
this.executingOutgoingHandlers--;
|
|
this.reuseBuffer(buffer);
|
|
this.emitter.emit("checkEnd");
|
|
}
|
|
reuseBuffer(buffer) {
|
|
this.incoming.push(buffer);
|
|
if (!this.isError && this.resolveData() && !this.isStreamEnd)
|
|
this.readable.resume();
|
|
}
|
|
}
|
|
var fsStat = util__namespace.promisify(fs__namespace.stat);
|
|
var fsCreateReadStream = fs__namespace.createReadStream;
|
|
|
|
class BlobClient extends StorageClient {
|
|
constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
|
|
options = options || {};
|
|
let pipeline;
|
|
let url2;
|
|
if (isPipelineLike(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = credentialOrPipelineOrContainerName;
|
|
} else if (coreHttp.isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
|
|
} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
|
|
url2 = urlOrConnectionString;
|
|
if (blobNameOrOptions && typeof blobNameOrOptions !== "string")
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
|
|
const containerName = credentialOrPipelineOrContainerName;
|
|
const blobName = blobNameOrOptions;
|
|
const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
pipeline = newPipeline(sharedKeyCredential, options);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
} else
|
|
throw new Error("Expecting non-empty strings for containerName and blobName parameters");
|
|
super(url2, pipeline);
|
|
({ blobName: this._name, containerName: this._containerName } = this.getBlobAndContainerNamesFromUrl());
|
|
this.blobContext = new Blob$1(this.storageClientContext);
|
|
this._snapshot = getURLParameter(this.url, URLConstants.Parameters.SNAPSHOT);
|
|
this._versionId = getURLParameter(this.url, URLConstants.Parameters.VERSIONID);
|
|
}
|
|
get name() {
|
|
return this._name;
|
|
}
|
|
get containerName() {
|
|
return this._containerName;
|
|
}
|
|
withSnapshot(snapshot2) {
|
|
return new BlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot2.length === 0 ? undefined : snapshot2), this.pipeline);
|
|
}
|
|
withVersion(versionId2) {
|
|
return new BlobClient(setURLParameter(this.url, URLConstants.Parameters.VERSIONID, versionId2.length === 0 ? undefined : versionId2), this.pipeline);
|
|
}
|
|
getAppendBlobClient() {
|
|
return new AppendBlobClient(this.url, this.pipeline);
|
|
}
|
|
getBlockBlobClient() {
|
|
return new BlockBlobClient(this.url, this.pipeline);
|
|
}
|
|
getPageBlobClient() {
|
|
return new PageBlobClient(this.url, this.pipeline);
|
|
}
|
|
async download(offset = 0, count, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
options.conditions = options.conditions || {};
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
const { span, updatedOptions } = createSpan("BlobClient-download", options);
|
|
try {
|
|
const res = await this.blobContext.download(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), requestOptions: {
|
|
onDownloadProgress: coreHttp.isNode ? undefined : options.onProgress
|
|
}, range: offset === 0 && !count ? undefined : rangeToString({ offset, count }), rangeGetContentMD5: options.rangeGetContentMD5, rangeGetContentCRC64: options.rangeGetContentCrc64, snapshot: options.snapshot, cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedRes = Object.assign(Object.assign({}, res), { _response: res._response, objectReplicationDestinationPolicyId: res.objectReplicationPolicyId, objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules) });
|
|
if (!coreHttp.isNode)
|
|
return wrappedRes;
|
|
if (options.maxRetryRequests === undefined || options.maxRetryRequests < 0)
|
|
options.maxRetryRequests = DEFAULT_MAX_DOWNLOAD_RETRY_REQUESTS;
|
|
if (res.contentLength === undefined)
|
|
throw new RangeError(`File download response doesn't contain valid content length header`);
|
|
if (!res.etag)
|
|
throw new RangeError(`File download response doesn't contain valid etag header`);
|
|
return new BlobDownloadResponse(wrappedRes, async (start) => {
|
|
var _a2;
|
|
const updatedDownloadOptions = {
|
|
leaseAccessConditions: options.conditions,
|
|
modifiedAccessConditions: {
|
|
ifMatch: options.conditions.ifMatch || res.etag,
|
|
ifModifiedSince: options.conditions.ifModifiedSince,
|
|
ifNoneMatch: options.conditions.ifNoneMatch,
|
|
ifUnmodifiedSince: options.conditions.ifUnmodifiedSince,
|
|
ifTags: (_a2 = options.conditions) === null || _a2 === undefined ? undefined : _a2.tagConditions
|
|
},
|
|
range: rangeToString({
|
|
count: offset + res.contentLength - start,
|
|
offset: start
|
|
}),
|
|
rangeGetContentMD5: options.rangeGetContentMD5,
|
|
rangeGetContentCRC64: options.rangeGetContentCrc64,
|
|
snapshot: options.snapshot,
|
|
cpkInfo: options.customerProvidedKey
|
|
};
|
|
return (await this.blobContext.download(Object.assign({ abortSignal: options.abortSignal }, updatedDownloadOptions))).readableStreamBody;
|
|
}, offset, res.contentLength, {
|
|
maxRetryRequests: options.maxRetryRequests,
|
|
onProgress: options.onProgress
|
|
});
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async exists(options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-exists", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
await this.getProperties({
|
|
abortSignal: options.abortSignal,
|
|
customerProvidedKey: options.customerProvidedKey,
|
|
conditions: options.conditions,
|
|
tracingOptions: updatedOptions.tracingOptions
|
|
});
|
|
return true;
|
|
} catch (e) {
|
|
if (e.statusCode === 404)
|
|
return false;
|
|
else if (e.statusCode === 409 && (e.details.errorCode === BlobUsesCustomerSpecifiedEncryptionMsg || e.details.errorCode === BlobDoesNotUseCustomerSpecifiedEncryption))
|
|
return true;
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getProperties(options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-getProperties", options);
|
|
try {
|
|
options.conditions = options.conditions || {};
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
const res = await this.blobContext.getProperties(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
return Object.assign(Object.assign({}, res), { _response: res._response, objectReplicationDestinationPolicyId: res.objectReplicationPolicyId, objectReplicationSourceProperties: parseObjectReplicationRecord(res.objectReplicationRules) });
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async delete(options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-delete", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
return await this.blobContext.delete(Object.assign({ abortSignal: options.abortSignal, deleteSnapshots: options.deleteSnapshots, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async deleteIfExists(options = {}) {
|
|
var _a, _b;
|
|
const { span, updatedOptions } = createSpan("BlobClient-deleteIfExists", options);
|
|
try {
|
|
const res = await this.delete(updatedOptions);
|
|
return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
|
|
} catch (e) {
|
|
if (((_a = e.details) === null || _a === undefined ? undefined : _a.errorCode) === "BlobNotFound") {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when deleting a blob or snapshot only if it exists."
|
|
});
|
|
return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === undefined ? undefined : _b.parsedHeaders), { _response: e.response });
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async undelete(options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-undelete", options);
|
|
try {
|
|
return await this.blobContext.undelete(Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setHTTPHeaders(blobHTTPHeaders, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-setHTTPHeaders", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blobContext.setHttpHeaders(Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: blobHTTPHeaders, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setMetadata(metadata2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-setMetadata", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blobContext.setMetadata(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: metadata2, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setTags(tags2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-setTags", options);
|
|
try {
|
|
return await this.blobContext.setTags(Object.assign(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)), { tags: toBlobTags(tags2) }));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getTags(options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-getTags", options);
|
|
try {
|
|
const response = await this.blobContext.getTags(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, tags: toTags({ blobTagSet: response.blobTagSet }) || {} });
|
|
return wrappedResponse;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
getBlobLeaseClient(proposeLeaseId) {
|
|
return new BlobLeaseClient(this, proposeLeaseId);
|
|
}
|
|
async createSnapshot(options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-createSnapshot", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blobContext.createSnapshot(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async beginCopyFromURL(copySource2, options = {}) {
|
|
const client = {
|
|
abortCopyFromURL: (...args) => this.abortCopyFromURL(...args),
|
|
getProperties: (...args) => this.getProperties(...args),
|
|
startCopyFromURL: (...args) => this.startCopyFromURL(...args)
|
|
};
|
|
const poller = new BlobBeginCopyFromUrlPoller({
|
|
blobClient: client,
|
|
copySource: copySource2,
|
|
intervalInMs: options.intervalInMs,
|
|
onProgress: options.onProgress,
|
|
resumeFrom: options.resumeFrom,
|
|
startCopyFromURLOptions: options
|
|
});
|
|
await poller.poll();
|
|
return poller;
|
|
}
|
|
async abortCopyFromURL(copyId2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-abortCopyFromURL", options);
|
|
try {
|
|
return await this.blobContext.abortCopyFromURL(copyId2, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async syncCopyFromURL(copySource2, options = {}) {
|
|
var _a, _b, _c;
|
|
const { span, updatedOptions } = createSpan("BlobClient-syncCopyFromURL", options);
|
|
options.conditions = options.conditions || {};
|
|
options.sourceConditions = options.sourceConditions || {};
|
|
try {
|
|
return await this.blobContext.copyFromURL(copySource2, Object.assign({ abortSignal: options.abortSignal, metadata: options.metadata, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), sourceModifiedAccessConditions: {
|
|
sourceIfMatch: options.sourceConditions.ifMatch,
|
|
sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
|
|
sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
|
|
sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince
|
|
}, sourceContentMD5: options.sourceContentMD5, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, encryptionScope: options.encryptionScope, copySourceTags: options.copySourceTags }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setAccessTier(tier2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobClient-setAccessTier", options);
|
|
try {
|
|
return await this.blobContext.setTier(toAccessTier(tier2), Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), rehydratePriority: options.rehydratePriority }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async downloadToBuffer(param1, param2, param3, param4 = {}) {
|
|
let buffer;
|
|
let offset = 0;
|
|
let count = 0;
|
|
let options = param4;
|
|
if (param1 instanceof Buffer) {
|
|
buffer = param1;
|
|
offset = param2 || 0;
|
|
count = typeof param3 === "number" ? param3 : 0;
|
|
} else {
|
|
offset = typeof param1 === "number" ? param1 : 0;
|
|
count = typeof param2 === "number" ? param2 : 0;
|
|
options = param3 || {};
|
|
}
|
|
const { span, updatedOptions } = createSpan("BlobClient-downloadToBuffer", options);
|
|
try {
|
|
if (!options.blockSize)
|
|
options.blockSize = 0;
|
|
if (options.blockSize < 0)
|
|
throw new RangeError("blockSize option must be >= 0");
|
|
if (options.blockSize === 0)
|
|
options.blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
|
|
if (offset < 0)
|
|
throw new RangeError("offset option must be >= 0");
|
|
if (count && count <= 0)
|
|
throw new RangeError("count option must be greater than 0");
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
if (!count) {
|
|
const response = await this.getProperties(Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
|
|
count = response.contentLength - offset;
|
|
if (count < 0)
|
|
throw new RangeError(`offset ${offset} shouldn't be larger than blob size ${response.contentLength}`);
|
|
}
|
|
if (!buffer)
|
|
try {
|
|
buffer = Buffer.alloc(count);
|
|
} catch (error) {
|
|
throw new Error(`Unable to allocate the buffer of size: ${count}(in bytes). Please try passing your own buffer to the "downloadToBuffer" method or try using other methods like "download" or "downloadToFile".\t ${error.message}`);
|
|
}
|
|
if (buffer.length < count)
|
|
throw new RangeError(`The buffer's size should be equal to or larger than the request count of bytes: ${count}`);
|
|
let transferProgress = 0;
|
|
const batch = new Batch(options.concurrency);
|
|
for (let off = offset;off < offset + count; off = off + options.blockSize)
|
|
batch.addOperation(async () => {
|
|
let chunkEnd = offset + count;
|
|
if (off + options.blockSize < chunkEnd)
|
|
chunkEnd = off + options.blockSize;
|
|
const response = await this.download(off, chunkEnd - off, {
|
|
abortSignal: options.abortSignal,
|
|
conditions: options.conditions,
|
|
maxRetryRequests: options.maxRetryRequestsPerBlock,
|
|
customerProvidedKey: options.customerProvidedKey,
|
|
tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions))
|
|
});
|
|
const stream2 = response.readableStreamBody;
|
|
await streamToBuffer(stream2, buffer, off - offset, chunkEnd - offset);
|
|
transferProgress += chunkEnd - off;
|
|
if (options.onProgress)
|
|
options.onProgress({ loadedBytes: transferProgress });
|
|
});
|
|
await batch.do();
|
|
return buffer;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async downloadToFile(filePath, offset = 0, count, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-downloadToFile", options);
|
|
try {
|
|
const response = await this.download(offset, count, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
|
|
if (response.readableStreamBody)
|
|
await readStreamToLocalFile(response.readableStreamBody, filePath);
|
|
response.blobDownloadStream = undefined;
|
|
return response;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
getBlobAndContainerNamesFromUrl() {
|
|
let containerName;
|
|
let blobName;
|
|
try {
|
|
const parsedUrl = coreHttp.URLBuilder.parse(this.url);
|
|
if (parsedUrl.getHost().split(".")[1] === "blob") {
|
|
const pathComponents = parsedUrl.getPath().match("/([^/]*)(/(.*))?");
|
|
containerName = pathComponents[1];
|
|
blobName = pathComponents[3];
|
|
} else if (isIpEndpointStyle(parsedUrl)) {
|
|
const pathComponents = parsedUrl.getPath().match("/([^/]*)/([^/]*)(/(.*))?");
|
|
containerName = pathComponents[2];
|
|
blobName = pathComponents[4];
|
|
} else {
|
|
const pathComponents = parsedUrl.getPath().match("/([^/]*)(/(.*))?");
|
|
containerName = pathComponents[1];
|
|
blobName = pathComponents[3];
|
|
}
|
|
containerName = decodeURIComponent(containerName);
|
|
blobName = decodeURIComponent(blobName);
|
|
blobName = blobName.replace(/\\/g, "/");
|
|
if (!containerName)
|
|
throw new Error("Provided containerName is invalid.");
|
|
return { blobName, containerName };
|
|
} catch (error) {
|
|
throw new Error("Unable to extract blobName and containerName with provided information.");
|
|
}
|
|
}
|
|
async startCopyFromURL(copySource2, options = {}) {
|
|
var _a, _b, _c;
|
|
const { span, updatedOptions } = createSpan("BlobClient-startCopyFromURL", options);
|
|
options.conditions = options.conditions || {};
|
|
options.sourceConditions = options.sourceConditions || {};
|
|
try {
|
|
return await this.blobContext.startCopyFromURL(copySource2, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), sourceModifiedAccessConditions: {
|
|
sourceIfMatch: options.sourceConditions.ifMatch,
|
|
sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
|
|
sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
|
|
sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince,
|
|
sourceIfTags: options.sourceConditions.tagConditions
|
|
}, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, rehydratePriority: options.rehydratePriority, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), sealBlob: options.sealBlob }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
generateSasUrl(options) {
|
|
return new Promise((resolve) => {
|
|
if (!(this.credential instanceof StorageSharedKeyCredential))
|
|
throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
|
|
const sas = generateBlobSASQueryParameters(Object.assign({ containerName: this._containerName, blobName: this._name, snapshotTime: this._snapshot, versionId: this._versionId }, options), this.credential).toString();
|
|
resolve(appendToURLQuery(this.url, sas));
|
|
});
|
|
}
|
|
async deleteImmutabilityPolicy(options) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-deleteImmutabilityPolicy", options);
|
|
try {
|
|
return await this.blobContext.deleteImmutabilityPolicy(Object.assign({ abortSignal: options === null || options === undefined ? undefined : options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setImmutabilityPolicy(immutabilityPolicy, options) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-setImmutabilityPolicy", options);
|
|
try {
|
|
return await this.blobContext.setImmutabilityPolicy(Object.assign({ abortSignal: options === null || options === undefined ? undefined : options.abortSignal, immutabilityPolicyExpiry: immutabilityPolicy.expiriesOn, immutabilityPolicyMode: immutabilityPolicy.policyMode, modifiedAccessConditions: options === null || options === undefined ? undefined : options.modifiedAccessCondition }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setLegalHold(legalHoldEnabled, options) {
|
|
const { span, updatedOptions } = createSpan("BlobClient-setLegalHold", options);
|
|
try {
|
|
return await this.blobContext.setLegalHold(legalHoldEnabled, Object.assign({ abortSignal: options === null || options === undefined ? undefined : options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class AppendBlobClient extends BlobClient {
|
|
constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
|
|
let pipeline;
|
|
let url2;
|
|
options = options || {};
|
|
if (isPipelineLike(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = credentialOrPipelineOrContainerName;
|
|
} else if (coreHttp.isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
|
|
} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
|
|
const containerName = credentialOrPipelineOrContainerName;
|
|
const blobName = blobNameOrOptions;
|
|
const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
pipeline = newPipeline(sharedKeyCredential, options);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
} else
|
|
throw new Error("Expecting non-empty strings for containerName and blobName parameters");
|
|
super(url2, pipeline);
|
|
this.appendBlobContext = new AppendBlob(this.storageClientContext);
|
|
}
|
|
withSnapshot(snapshot2) {
|
|
return new AppendBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot2.length === 0 ? undefined : snapshot2), this.pipeline);
|
|
}
|
|
async create(options = {}) {
|
|
var _a, _b, _c;
|
|
const { span, updatedOptions } = createSpan("AppendBlobClient-create", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.appendBlobContext.create(0, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async createIfNotExists(options = {}) {
|
|
var _a, _b;
|
|
const { span, updatedOptions } = createSpan("AppendBlobClient-createIfNotExists", options);
|
|
const conditions = { ifNoneMatch: ETagAny };
|
|
try {
|
|
const res = await this.create(Object.assign(Object.assign({}, updatedOptions), { conditions }));
|
|
return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
|
|
} catch (e) {
|
|
if (((_a = e.details) === null || _a === undefined ? undefined : _a.errorCode) === "BlobAlreadyExists") {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when creating a blob only if it does not already exist."
|
|
});
|
|
return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === undefined ? undefined : _b.parsedHeaders), { _response: e.response });
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async seal(options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("AppendBlobClient-seal", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
return await this.appendBlobContext.seal(Object.assign({ abortSignal: options.abortSignal, appendPositionAccessConditions: options.conditions, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async appendBlock(body2, contentLength2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("AppendBlobClient-appendBlock", options);
|
|
options.conditions = options.conditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.appendBlobContext.appendBlock(contentLength2, body2, Object.assign({ abortSignal: options.abortSignal, appendPositionAccessConditions: options.conditions, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), requestOptions: {
|
|
onUploadProgress: options.onProgress
|
|
}, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async appendBlockFromURL(sourceURL, sourceOffset, count, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("AppendBlobClient-appendBlockFromURL", options);
|
|
options.conditions = options.conditions || {};
|
|
options.sourceConditions = options.sourceConditions || {};
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.appendBlobContext.appendBlockFromUrl(sourceURL, 0, Object.assign({ abortSignal: options.abortSignal, sourceRange: rangeToString({ offset: sourceOffset, count }), sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, leaseAccessConditions: options.conditions, appendPositionAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), sourceModifiedAccessConditions: {
|
|
sourceIfMatch: options.sourceConditions.ifMatch,
|
|
sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
|
|
sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
|
|
sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince
|
|
}, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class BlockBlobClient extends BlobClient {
|
|
constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
|
|
let pipeline;
|
|
let url2;
|
|
options = options || {};
|
|
if (isPipelineLike(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = credentialOrPipelineOrContainerName;
|
|
} else if (coreHttp.isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
|
|
} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
|
|
url2 = urlOrConnectionString;
|
|
if (blobNameOrOptions && typeof blobNameOrOptions !== "string")
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
|
|
const containerName = credentialOrPipelineOrContainerName;
|
|
const blobName = blobNameOrOptions;
|
|
const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
pipeline = newPipeline(sharedKeyCredential, options);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
} else
|
|
throw new Error("Expecting non-empty strings for containerName and blobName parameters");
|
|
super(url2, pipeline);
|
|
this.blockBlobContext = new BlockBlob(this.storageClientContext);
|
|
this._blobContext = new Blob$1(this.storageClientContext);
|
|
}
|
|
withSnapshot(snapshot2) {
|
|
return new BlockBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot2.length === 0 ? undefined : snapshot2), this.pipeline);
|
|
}
|
|
async query(query, options = {}) {
|
|
var _a;
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-query", options);
|
|
try {
|
|
if (!coreHttp.isNode)
|
|
throw new Error("This operation currently is only supported in Node.js.");
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
const response = await this._blobContext.query(Object.assign({ abortSignal: options.abortSignal, queryRequest: {
|
|
queryType: "SQL",
|
|
expression: query,
|
|
inputSerialization: toQuerySerialization(options.inputTextConfiguration),
|
|
outputSerialization: toQuerySerialization(options.outputTextConfiguration)
|
|
}, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
return new BlobQueryResponse(response, {
|
|
abortSignal: options.abortSignal,
|
|
onProgress: options.onProgress,
|
|
onError: options.onError
|
|
});
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async upload(body2, contentLength2, options = {}) {
|
|
var _a, _b, _c;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-upload", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blockBlobContext.upload(contentLength2, body2, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), requestOptions: {
|
|
onUploadProgress: options.onProgress
|
|
}, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async syncUploadFromURL(sourceURL, options = {}) {
|
|
var _a, _b, _c, _d, _e;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-syncUploadFromURL", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blockBlobContext.putBlobFromUrl(0, sourceURL, Object.assign(Object.assign(Object.assign({}, options), { blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: options.conditions.tagConditions }), sourceModifiedAccessConditions: {
|
|
sourceIfMatch: (_a = options.sourceConditions) === null || _a === undefined ? undefined : _a.ifMatch,
|
|
sourceIfModifiedSince: (_b = options.sourceConditions) === null || _b === undefined ? undefined : _b.ifModifiedSince,
|
|
sourceIfNoneMatch: (_c = options.sourceConditions) === null || _c === undefined ? undefined : _c.ifNoneMatch,
|
|
sourceIfUnmodifiedSince: (_d = options.sourceConditions) === null || _d === undefined ? undefined : _d.ifUnmodifiedSince,
|
|
sourceIfTags: (_e = options.sourceConditions) === null || _e === undefined ? undefined : _e.tagConditions
|
|
}, cpkInfo: options.customerProvidedKey, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization), tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags), copySourceTags: options.copySourceTags }), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async stageBlock(blockId2, body2, contentLength2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-stageBlock", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blockBlobContext.stageBlock(blockId2, contentLength2, body2, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, requestOptions: {
|
|
onUploadProgress: options.onProgress
|
|
}, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async stageBlockFromURL(blockId2, sourceURL, offset = 0, count, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-stageBlockFromURL", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blockBlobContext.stageBlockFromURL(blockId2, 0, sourceURL, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, sourceRange: offset === 0 && !count ? undefined : rangeToString({ offset, count }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async commitBlockList(blocks2, options = {}) {
|
|
var _a, _b, _c;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-commitBlockList", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.blockBlobContext.commitBlockList({ latest: blocks2 }, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getBlockList(listType2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-getBlockList", options);
|
|
try {
|
|
const res = await this.blockBlobContext.getBlockList(listType2, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
if (!res.committedBlocks)
|
|
res.committedBlocks = [];
|
|
if (!res.uncommittedBlocks)
|
|
res.uncommittedBlocks = [];
|
|
return res;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadData(data, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-uploadData", options);
|
|
try {
|
|
if (coreHttp.isNode) {
|
|
let buffer;
|
|
if (data instanceof Buffer)
|
|
buffer = data;
|
|
else if (data instanceof ArrayBuffer)
|
|
buffer = Buffer.from(data);
|
|
else {
|
|
data = data;
|
|
buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
|
|
}
|
|
return this.uploadSeekableInternal((offset, size) => buffer.slice(offset, offset + size), buffer.byteLength, updatedOptions);
|
|
} else {
|
|
const browserBlob = new Blob([data]);
|
|
return this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
|
|
}
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadBrowserData(browserData, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-uploadBrowserData", options);
|
|
try {
|
|
const browserBlob = new Blob([browserData]);
|
|
return await this.uploadSeekableInternal((offset, size) => browserBlob.slice(offset, offset + size), browserBlob.size, updatedOptions);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadSeekableInternal(bodyFactory, size, options = {}) {
|
|
if (!options.blockSize)
|
|
options.blockSize = 0;
|
|
if (options.blockSize < 0 || options.blockSize > BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES)
|
|
throw new RangeError(`blockSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES}`);
|
|
if (options.maxSingleShotSize !== 0 && !options.maxSingleShotSize)
|
|
options.maxSingleShotSize = BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES;
|
|
if (options.maxSingleShotSize < 0 || options.maxSingleShotSize > BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES)
|
|
throw new RangeError(`maxSingleShotSize option must be >= 0 and <= ${BLOCK_BLOB_MAX_UPLOAD_BLOB_BYTES}`);
|
|
if (options.blockSize === 0) {
|
|
if (size > BLOCK_BLOB_MAX_STAGE_BLOCK_BYTES * BLOCK_BLOB_MAX_BLOCKS)
|
|
throw new RangeError(`${size} is too larger to upload to a block blob.`);
|
|
if (size > options.maxSingleShotSize) {
|
|
options.blockSize = Math.ceil(size / BLOCK_BLOB_MAX_BLOCKS);
|
|
if (options.blockSize < DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES)
|
|
options.blockSize = DEFAULT_BLOB_DOWNLOAD_BLOCK_BYTES;
|
|
}
|
|
}
|
|
if (!options.blobHTTPHeaders)
|
|
options.blobHTTPHeaders = {};
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-uploadSeekableInternal", options);
|
|
try {
|
|
if (size <= options.maxSingleShotSize)
|
|
return await this.upload(bodyFactory(0, size), size, updatedOptions);
|
|
const numBlocks = Math.floor((size - 1) / options.blockSize) + 1;
|
|
if (numBlocks > BLOCK_BLOB_MAX_BLOCKS)
|
|
throw new RangeError(`The buffer's size is too big or the BlockSize is too small;` + `the number of blocks must be <= ${BLOCK_BLOB_MAX_BLOCKS}`);
|
|
const blockList = [];
|
|
const blockIDPrefix = coreHttp.generateUuid();
|
|
let transferProgress = 0;
|
|
const batch = new Batch(options.concurrency);
|
|
for (let i = 0;i < numBlocks; i++)
|
|
batch.addOperation(async () => {
|
|
const blockID = generateBlockID(blockIDPrefix, i);
|
|
const start = options.blockSize * i;
|
|
const end = i === numBlocks - 1 ? size : start + options.blockSize;
|
|
const contentLength2 = end - start;
|
|
blockList.push(blockID);
|
|
await this.stageBlock(blockID, bodyFactory(start, contentLength2), contentLength2, {
|
|
abortSignal: options.abortSignal,
|
|
conditions: options.conditions,
|
|
encryptionScope: options.encryptionScope,
|
|
tracingOptions: updatedOptions.tracingOptions
|
|
});
|
|
transferProgress += contentLength2;
|
|
if (options.onProgress)
|
|
options.onProgress({
|
|
loadedBytes: transferProgress
|
|
});
|
|
});
|
|
await batch.do();
|
|
return this.commitBlockList(blockList, updatedOptions);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadFile(filePath, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-uploadFile", options);
|
|
try {
|
|
const size = (await fsStat(filePath)).size;
|
|
return await this.uploadSeekableInternal((offset, count) => {
|
|
return () => fsCreateReadStream(filePath, {
|
|
autoClose: true,
|
|
end: count ? offset + count - 1 : Infinity,
|
|
start: offset
|
|
});
|
|
}, size, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadStream(stream2, bufferSize = DEFAULT_BLOCK_BUFFER_SIZE_BYTES, maxConcurrency = 5, options = {}) {
|
|
if (!options.blobHTTPHeaders)
|
|
options.blobHTTPHeaders = {};
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
const { span, updatedOptions } = createSpan("BlockBlobClient-uploadStream", options);
|
|
try {
|
|
let blockNum = 0;
|
|
const blockIDPrefix = coreHttp.generateUuid();
|
|
let transferProgress = 0;
|
|
const blockList = [];
|
|
const scheduler = new BufferScheduler(stream2, bufferSize, maxConcurrency, async (body2, length) => {
|
|
const blockID = generateBlockID(blockIDPrefix, blockNum);
|
|
blockList.push(blockID);
|
|
blockNum++;
|
|
await this.stageBlock(blockID, body2, length, {
|
|
conditions: options.conditions,
|
|
encryptionScope: options.encryptionScope,
|
|
tracingOptions: updatedOptions.tracingOptions
|
|
});
|
|
transferProgress += length;
|
|
if (options.onProgress)
|
|
options.onProgress({ loadedBytes: transferProgress });
|
|
}, Math.ceil(maxConcurrency / 4 * 3));
|
|
await scheduler.do();
|
|
return await this.commitBlockList(blockList, Object.assign(Object.assign({}, options), { tracingOptions: Object.assign(Object.assign({}, options.tracingOptions), convertTracingToRequestOptionsBase(updatedOptions)) }));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class PageBlobClient extends BlobClient {
|
|
constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, blobNameOrOptions, options) {
|
|
let pipeline;
|
|
let url2;
|
|
options = options || {};
|
|
if (isPipelineLike(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = credentialOrPipelineOrContainerName;
|
|
} else if (coreHttp.isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
options = blobNameOrOptions;
|
|
pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
|
|
} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string" && blobNameOrOptions && typeof blobNameOrOptions === "string") {
|
|
const containerName = credentialOrPipelineOrContainerName;
|
|
const blobName = blobNameOrOptions;
|
|
const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName));
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
pipeline = newPipeline(sharedKeyCredential, options);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
url2 = appendToURLPath(appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)), encodeURIComponent(blobName)) + "?" + extractedCreds.accountSas;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
} else
|
|
throw new Error("Expecting non-empty strings for containerName and blobName parameters");
|
|
super(url2, pipeline);
|
|
this.pageBlobContext = new PageBlob(this.storageClientContext);
|
|
}
|
|
withSnapshot(snapshot2) {
|
|
return new PageBlobClient(setURLParameter(this.url, URLConstants.Parameters.SNAPSHOT, snapshot2.length === 0 ? undefined : snapshot2), this.pipeline);
|
|
}
|
|
async create(size, options = {}) {
|
|
var _a, _b, _c;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-create", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.pageBlobContext.create(0, size, Object.assign({ abortSignal: options.abortSignal, blobHttpHeaders: options.blobHTTPHeaders, blobSequenceNumber: options.blobSequenceNumber, leaseAccessConditions: options.conditions, metadata: options.metadata, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, immutabilityPolicyExpiry: (_b = options.immutabilityPolicy) === null || _b === undefined ? undefined : _b.expiriesOn, immutabilityPolicyMode: (_c = options.immutabilityPolicy) === null || _c === undefined ? undefined : _c.policyMode, legalHold: options.legalHold, tier: toAccessTier(options.tier), blobTagsString: toBlobTagsString(options.tags) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async createIfNotExists(size, options = {}) {
|
|
var _a, _b;
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-createIfNotExists", options);
|
|
try {
|
|
const conditions = { ifNoneMatch: ETagAny };
|
|
const res = await this.create(size, Object.assign(Object.assign({}, options), { conditions, tracingOptions: updatedOptions.tracingOptions }));
|
|
return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
|
|
} catch (e) {
|
|
if (((_a = e.details) === null || _a === undefined ? undefined : _a.errorCode) === "BlobAlreadyExists") {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when creating a blob only if it does not already exist."
|
|
});
|
|
return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === undefined ? undefined : _b.parsedHeaders), { _response: e.response });
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadPages(body2, offset, count, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-uploadPages", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.pageBlobContext.uploadPages(count, body2, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), requestOptions: {
|
|
onUploadProgress: options.onProgress
|
|
}, range: rangeToString({ offset, count }), sequenceNumberAccessConditions: options.conditions, transactionalContentMD5: options.transactionalContentMD5, transactionalContentCrc64: options.transactionalContentCrc64, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async uploadPagesFromURL(sourceURL, sourceOffset, destOffset, count, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
options.sourceConditions = options.sourceConditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-uploadPagesFromURL", options);
|
|
try {
|
|
ensureCpkIfSpecified(options.customerProvidedKey, this.isHttps);
|
|
return await this.pageBlobContext.uploadPagesFromURL(sourceURL, rangeToString({ offset: sourceOffset, count }), 0, rangeToString({ offset: destOffset, count }), Object.assign({ abortSignal: options.abortSignal, sourceContentMD5: options.sourceContentMD5, sourceContentCrc64: options.sourceContentCrc64, leaseAccessConditions: options.conditions, sequenceNumberAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), sourceModifiedAccessConditions: {
|
|
sourceIfMatch: options.sourceConditions.ifMatch,
|
|
sourceIfModifiedSince: options.sourceConditions.ifModifiedSince,
|
|
sourceIfNoneMatch: options.sourceConditions.ifNoneMatch,
|
|
sourceIfUnmodifiedSince: options.sourceConditions.ifUnmodifiedSince
|
|
}, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope, copySourceAuthorization: httpAuthorizationToString(options.sourceAuthorization) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async clearPages(offset = 0, count, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-clearPages", options);
|
|
try {
|
|
return await this.pageBlobContext.clearPages(0, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), range: rangeToString({ offset, count }), sequenceNumberAccessConditions: options.conditions, cpkInfo: options.customerProvidedKey, encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getPageRanges(offset = 0, count, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-getPageRanges", options);
|
|
try {
|
|
return await this.pageBlobContext.getPageRanges(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions))).then(rangeResponseFromModel);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async listPageRangesSegment(offset = 0, count, marker2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesSegment", options);
|
|
try {
|
|
return await this.pageBlobContext.getPageRanges(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), range: rangeToString({ offset, count }), marker: marker2, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
listPageRangeItemSegments(offset = 0, count, marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listPageRangeItemSegments_1() {
|
|
let getPageRangeItemSegmentsResponse;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
getPageRangeItemSegmentsResponse = yield tslib.__await(this.listPageRangesSegment(offset, count, marker2, options));
|
|
marker2 = getPageRangeItemSegmentsResponse.continuationToken;
|
|
yield yield tslib.__await(yield tslib.__await(getPageRangeItemSegmentsResponse));
|
|
} while (marker2);
|
|
});
|
|
}
|
|
listPageRangeItems(offset = 0, count, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listPageRangeItems_1() {
|
|
var e_1, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.listPageRangeItemSegments(offset, count, marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const getPageRangesSegment = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(ExtractPageRangeInfoItems(getPageRangesSegment))));
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_1)
|
|
throw e_1.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
listPageRanges(offset = 0, count, options = {}) {
|
|
options.conditions = options.conditions || {};
|
|
const iter = this.listPageRangeItems(offset, count, options);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.listPageRangeItemSegments(offset, count, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, options));
|
|
}
|
|
};
|
|
}
|
|
async getPageRangesDiff(offset, count, prevSnapshot, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesDiff", options);
|
|
try {
|
|
return await this.pageBlobContext.getPageRangesDiff(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), prevsnapshot: prevSnapshot, range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions))).then(rangeResponseFromModel);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker2, options) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-getPageRangesDiffSegment", options);
|
|
try {
|
|
return await this.pageBlobContext.getPageRangesDiff(Object.assign({ abortSignal: options === null || options === undefined ? undefined : options.abortSignal, leaseAccessConditions: options === null || options === undefined ? undefined : options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options === null || options === undefined ? undefined : options.conditions), { ifTags: (_a = options === null || options === undefined ? undefined : options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), prevsnapshot: prevSnapshotOrUrl, range: rangeToString({
|
|
offset,
|
|
count
|
|
}), marker: marker2, maxPageSize: options === null || options === undefined ? undefined : options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
listPageRangeDiffItemSegments(offset, count, prevSnapshotOrUrl, marker2, options) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listPageRangeDiffItemSegments_1() {
|
|
let getPageRangeItemSegmentsResponse;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
getPageRangeItemSegmentsResponse = yield tslib.__await(this.listPageRangesDiffSegment(offset, count, prevSnapshotOrUrl, marker2, options));
|
|
marker2 = getPageRangeItemSegmentsResponse.continuationToken;
|
|
yield yield tslib.__await(yield tslib.__await(getPageRangeItemSegmentsResponse));
|
|
} while (marker2);
|
|
});
|
|
}
|
|
listPageRangeDiffItems(offset, count, prevSnapshotOrUrl, options) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listPageRangeDiffItems_1() {
|
|
var e_2, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.listPageRangeDiffItemSegments(offset, count, prevSnapshotOrUrl, marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const getPageRangesSegment = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(ExtractPageRangeInfoItems(getPageRangesSegment))));
|
|
}
|
|
} catch (e_2_1) {
|
|
e_2 = { error: e_2_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_2)
|
|
throw e_2.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
listPageRangesDiff(offset, count, prevSnapshot, options = {}) {
|
|
options.conditions = options.conditions || {};
|
|
const iter = this.listPageRangeDiffItems(offset, count, prevSnapshot, Object.assign({}, options));
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.listPageRangeDiffItemSegments(offset, count, prevSnapshot, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, options));
|
|
}
|
|
};
|
|
}
|
|
async getPageRangesDiffForManagedDisks(offset, count, prevSnapshotUrl2, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-GetPageRangesDiffForManagedDisks", options);
|
|
try {
|
|
return await this.pageBlobContext.getPageRangesDiff(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), prevSnapshotUrl: prevSnapshotUrl2, range: rangeToString({ offset, count }) }, convertTracingToRequestOptionsBase(updatedOptions))).then(rangeResponseFromModel);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async resize(size, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-resize", options);
|
|
try {
|
|
return await this.pageBlobContext.resize(size, Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }), encryptionScope: options.encryptionScope }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async updateSequenceNumber(sequenceNumberAction2, sequenceNumber, options = {}) {
|
|
var _a;
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-updateSequenceNumber", options);
|
|
try {
|
|
return await this.pageBlobContext.updateSequenceNumber(sequenceNumberAction2, Object.assign({ abortSignal: options.abortSignal, blobSequenceNumber: sequenceNumber, leaseAccessConditions: options.conditions, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async startCopyIncremental(copySource2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("PageBlobClient-startCopyIncremental", options);
|
|
try {
|
|
return await this.pageBlobContext.copyIncremental(copySource2, Object.assign({ abortSignal: options.abortSignal, modifiedAccessConditions: Object.assign(Object.assign({}, options.conditions), { ifTags: (_a = options.conditions) === null || _a === undefined ? undefined : _a.tagConditions }) }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
var HTTP_HEADER_DELIMITER = ": ";
|
|
var SPACE_DELIMITER = " ";
|
|
var NOT_FOUND = -1;
|
|
|
|
class BatchResponseParser {
|
|
constructor(batchResponse, subRequests) {
|
|
if (!batchResponse || !batchResponse.contentType)
|
|
throw new RangeError("batchResponse is malformed or doesn't contain valid content-type.");
|
|
if (!subRequests || subRequests.size === 0)
|
|
throw new RangeError("Invalid state: subRequests is not provided or size is 0.");
|
|
this.batchResponse = batchResponse;
|
|
this.subRequests = subRequests;
|
|
this.responseBatchBoundary = this.batchResponse.contentType.split("=")[1];
|
|
this.perResponsePrefix = `--${this.responseBatchBoundary}${HTTP_LINE_ENDING}`;
|
|
this.batchResponseEnding = `--${this.responseBatchBoundary}--`;
|
|
}
|
|
async parseBatchResponse() {
|
|
if (this.batchResponse._response.status !== HTTPURLConnection.HTTP_ACCEPTED)
|
|
throw new Error(`Invalid state: batch request failed with status: '${this.batchResponse._response.status}'.`);
|
|
const responseBodyAsText = await getBodyAsText(this.batchResponse);
|
|
const subResponses = responseBodyAsText.split(this.batchResponseEnding)[0].split(this.perResponsePrefix).slice(1);
|
|
const subResponseCount = subResponses.length;
|
|
if (subResponseCount !== this.subRequests.size && subResponseCount !== 1)
|
|
throw new Error("Invalid state: sub responses' count is not equal to sub requests' count.");
|
|
const deserializedSubResponses = new Array(subResponseCount);
|
|
let subResponsesSucceededCount = 0;
|
|
let subResponsesFailedCount = 0;
|
|
for (let index = 0;index < subResponseCount; index++) {
|
|
const subResponse = subResponses[index];
|
|
const deserializedSubResponse = {};
|
|
deserializedSubResponse.headers = new coreHttp.HttpHeaders;
|
|
const responseLines = subResponse.split(`${HTTP_LINE_ENDING}`);
|
|
let subRespHeaderStartFound = false;
|
|
let subRespHeaderEndFound = false;
|
|
let subRespFailed = false;
|
|
let contentId = NOT_FOUND;
|
|
for (const responseLine of responseLines) {
|
|
if (!subRespHeaderStartFound) {
|
|
if (responseLine.startsWith(HeaderConstants.CONTENT_ID))
|
|
contentId = parseInt(responseLine.split(HTTP_HEADER_DELIMITER)[1]);
|
|
if (responseLine.startsWith(HTTP_VERSION_1_1)) {
|
|
subRespHeaderStartFound = true;
|
|
const tokens = responseLine.split(SPACE_DELIMITER);
|
|
deserializedSubResponse.status = parseInt(tokens[1]);
|
|
deserializedSubResponse.statusMessage = tokens.slice(2).join(SPACE_DELIMITER);
|
|
}
|
|
continue;
|
|
}
|
|
if (responseLine.trim() === "") {
|
|
if (!subRespHeaderEndFound)
|
|
subRespHeaderEndFound = true;
|
|
continue;
|
|
}
|
|
if (!subRespHeaderEndFound) {
|
|
if (responseLine.indexOf(HTTP_HEADER_DELIMITER) === -1)
|
|
throw new Error(`Invalid state: find non-empty line '${responseLine}' without HTTP header delimiter '${HTTP_HEADER_DELIMITER}'.`);
|
|
const tokens = responseLine.split(HTTP_HEADER_DELIMITER);
|
|
deserializedSubResponse.headers.set(tokens[0], tokens[1]);
|
|
if (tokens[0] === HeaderConstants.X_MS_ERROR_CODE) {
|
|
deserializedSubResponse.errorCode = tokens[1];
|
|
subRespFailed = true;
|
|
}
|
|
} else {
|
|
if (!deserializedSubResponse.bodyAsText)
|
|
deserializedSubResponse.bodyAsText = "";
|
|
deserializedSubResponse.bodyAsText += responseLine;
|
|
}
|
|
}
|
|
if (contentId !== NOT_FOUND && Number.isInteger(contentId) && contentId >= 0 && contentId < this.subRequests.size && deserializedSubResponses[contentId] === undefined) {
|
|
deserializedSubResponse._request = this.subRequests.get(contentId);
|
|
deserializedSubResponses[contentId] = deserializedSubResponse;
|
|
} else
|
|
logger.error(`subResponses[${index}] is dropped as the Content-ID is not found or invalid, Content-ID: ${contentId}`);
|
|
if (subRespFailed)
|
|
subResponsesFailedCount++;
|
|
else
|
|
subResponsesSucceededCount++;
|
|
}
|
|
return {
|
|
subResponses: deserializedSubResponses,
|
|
subResponsesSucceededCount,
|
|
subResponsesFailedCount
|
|
};
|
|
}
|
|
}
|
|
var MutexLockStatus;
|
|
(function(MutexLockStatus2) {
|
|
MutexLockStatus2[MutexLockStatus2["LOCKED"] = 0] = "LOCKED";
|
|
MutexLockStatus2[MutexLockStatus2["UNLOCKED"] = 1] = "UNLOCKED";
|
|
})(MutexLockStatus || (MutexLockStatus = {}));
|
|
|
|
class Mutex {
|
|
static async lock(key) {
|
|
return new Promise((resolve) => {
|
|
if (this.keys[key] === undefined || this.keys[key] === MutexLockStatus.UNLOCKED) {
|
|
this.keys[key] = MutexLockStatus.LOCKED;
|
|
resolve();
|
|
} else
|
|
this.onUnlockEvent(key, () => {
|
|
this.keys[key] = MutexLockStatus.LOCKED;
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
static async unlock(key) {
|
|
return new Promise((resolve) => {
|
|
if (this.keys[key] === MutexLockStatus.LOCKED)
|
|
this.emitUnlockEvent(key);
|
|
delete this.keys[key];
|
|
resolve();
|
|
});
|
|
}
|
|
static onUnlockEvent(key, handler) {
|
|
if (this.listeners[key] === undefined)
|
|
this.listeners[key] = [handler];
|
|
else
|
|
this.listeners[key].push(handler);
|
|
}
|
|
static emitUnlockEvent(key) {
|
|
if (this.listeners[key] !== undefined && this.listeners[key].length > 0) {
|
|
const handler = this.listeners[key].shift();
|
|
setImmediate(() => {
|
|
handler.call(this);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
Mutex.keys = {};
|
|
Mutex.listeners = {};
|
|
|
|
class BlobBatch {
|
|
constructor() {
|
|
this.batch = "batch";
|
|
this.batchRequest = new InnerBatchRequest;
|
|
}
|
|
getMultiPartContentType() {
|
|
return this.batchRequest.getMultipartContentType();
|
|
}
|
|
getHttpRequestBody() {
|
|
return this.batchRequest.getHttpRequestBody();
|
|
}
|
|
getSubRequests() {
|
|
return this.batchRequest.getSubRequests();
|
|
}
|
|
async addSubRequestInternal(subRequest, assembleSubRequestFunc) {
|
|
await Mutex.lock(this.batch);
|
|
try {
|
|
this.batchRequest.preAddSubRequest(subRequest);
|
|
await assembleSubRequestFunc();
|
|
this.batchRequest.postAddSubRequest(subRequest);
|
|
} finally {
|
|
await Mutex.unlock(this.batch);
|
|
}
|
|
}
|
|
setBatchType(batchType) {
|
|
if (!this.batchType)
|
|
this.batchType = batchType;
|
|
if (this.batchType !== batchType)
|
|
throw new RangeError(`BlobBatch only supports one operation type per batch and it already is being used for ${this.batchType} operations.`);
|
|
}
|
|
async deleteBlob(urlOrBlobClient, credentialOrOptions, options) {
|
|
let url2;
|
|
let credential;
|
|
if (typeof urlOrBlobClient === "string" && (coreHttp.isNode && credentialOrOptions instanceof StorageSharedKeyCredential || credentialOrOptions instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrOptions))) {
|
|
url2 = urlOrBlobClient;
|
|
credential = credentialOrOptions;
|
|
} else if (urlOrBlobClient instanceof BlobClient) {
|
|
url2 = urlOrBlobClient.url;
|
|
credential = urlOrBlobClient.credential;
|
|
options = credentialOrOptions;
|
|
} else
|
|
throw new RangeError("Invalid arguments. Either url and credential, or BlobClient need be provided.");
|
|
if (!options)
|
|
options = {};
|
|
const { span, updatedOptions } = createSpan("BatchDeleteRequest-addSubRequest", options);
|
|
try {
|
|
this.setBatchType("delete");
|
|
await this.addSubRequestInternal({
|
|
url: url2,
|
|
credential
|
|
}, async () => {
|
|
await new BlobClient(url2, this.batchRequest.createPipeline(credential)).delete(updatedOptions);
|
|
});
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions, options) {
|
|
let url2;
|
|
let credential;
|
|
let tier2;
|
|
if (typeof urlOrBlobClient === "string" && (coreHttp.isNode && credentialOrTier instanceof StorageSharedKeyCredential || credentialOrTier instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrTier))) {
|
|
url2 = urlOrBlobClient;
|
|
credential = credentialOrTier;
|
|
tier2 = tierOrOptions;
|
|
} else if (urlOrBlobClient instanceof BlobClient) {
|
|
url2 = urlOrBlobClient.url;
|
|
credential = urlOrBlobClient.credential;
|
|
tier2 = credentialOrTier;
|
|
options = tierOrOptions;
|
|
} else
|
|
throw new RangeError("Invalid arguments. Either url and credential, or BlobClient need be provided.");
|
|
if (!options)
|
|
options = {};
|
|
const { span, updatedOptions } = createSpan("BatchSetTierRequest-addSubRequest", options);
|
|
try {
|
|
this.setBatchType("setAccessTier");
|
|
await this.addSubRequestInternal({
|
|
url: url2,
|
|
credential
|
|
}, async () => {
|
|
await new BlobClient(url2, this.batchRequest.createPipeline(credential)).setAccessTier(tier2, updatedOptions);
|
|
});
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class InnerBatchRequest {
|
|
constructor() {
|
|
this.operationCount = 0;
|
|
this.body = "";
|
|
const tempGuid = coreHttp.generateUuid();
|
|
this.boundary = `batch_${tempGuid}`;
|
|
this.subRequestPrefix = `--${this.boundary}${HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TYPE}: application/http${HTTP_LINE_ENDING}${HeaderConstants.CONTENT_TRANSFER_ENCODING}: binary`;
|
|
this.multipartContentType = `multipart/mixed; boundary=${this.boundary}`;
|
|
this.batchRequestEnding = `--${this.boundary}--`;
|
|
this.subRequests = new Map;
|
|
}
|
|
createPipeline(credential) {
|
|
const isAnonymousCreds = credential instanceof AnonymousCredential;
|
|
const policyFactoryLength = 3 + (isAnonymousCreds ? 0 : 1);
|
|
const factories = new Array(policyFactoryLength);
|
|
factories[0] = coreHttp.deserializationPolicy();
|
|
factories[1] = new BatchHeaderFilterPolicyFactory;
|
|
if (!isAnonymousCreds)
|
|
factories[2] = coreHttp.isTokenCredential(credential) ? attachCredential(coreHttp.bearerTokenAuthenticationPolicy(credential, StorageOAuthScopes), credential) : credential;
|
|
factories[policyFactoryLength - 1] = new BatchRequestAssemblePolicyFactory(this);
|
|
return new Pipeline(factories, {});
|
|
}
|
|
appendSubRequestToBody(request) {
|
|
this.body += [
|
|
this.subRequestPrefix,
|
|
`${HeaderConstants.CONTENT_ID}: ${this.operationCount}`,
|
|
"",
|
|
`${request.method.toString()} ${getURLPathAndQuery(request.url)} ${HTTP_VERSION_1_1}${HTTP_LINE_ENDING}`
|
|
].join(HTTP_LINE_ENDING);
|
|
for (const header of request.headers.headersArray())
|
|
this.body += `${header.name}: ${header.value}${HTTP_LINE_ENDING}`;
|
|
this.body += HTTP_LINE_ENDING;
|
|
}
|
|
preAddSubRequest(subRequest) {
|
|
if (this.operationCount >= BATCH_MAX_REQUEST)
|
|
throw new RangeError(`Cannot exceed ${BATCH_MAX_REQUEST} sub requests in a single batch`);
|
|
const path = getURLPath(subRequest.url);
|
|
if (!path || path === "")
|
|
throw new RangeError(`Invalid url for sub request: '${subRequest.url}'`);
|
|
}
|
|
postAddSubRequest(subRequest) {
|
|
this.subRequests.set(this.operationCount, subRequest);
|
|
this.operationCount++;
|
|
}
|
|
getHttpRequestBody() {
|
|
return `${this.body}${this.batchRequestEnding}${HTTP_LINE_ENDING}`;
|
|
}
|
|
getMultipartContentType() {
|
|
return this.multipartContentType;
|
|
}
|
|
getSubRequests() {
|
|
return this.subRequests;
|
|
}
|
|
}
|
|
|
|
class BatchRequestAssemblePolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(batchRequest, nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
this.dummyResponse = {
|
|
request: new coreHttp.WebResource,
|
|
status: 200,
|
|
headers: new coreHttp.HttpHeaders
|
|
};
|
|
this.batchRequest = batchRequest;
|
|
}
|
|
async sendRequest(request) {
|
|
await this.batchRequest.appendSubRequestToBody(request);
|
|
return this.dummyResponse;
|
|
}
|
|
}
|
|
|
|
class BatchRequestAssemblePolicyFactory {
|
|
constructor(batchRequest) {
|
|
this.batchRequest = batchRequest;
|
|
}
|
|
create(nextPolicy, options) {
|
|
return new BatchRequestAssemblePolicy(this.batchRequest, nextPolicy, options);
|
|
}
|
|
}
|
|
|
|
class BatchHeaderFilterPolicy extends coreHttp.BaseRequestPolicy {
|
|
constructor(nextPolicy, options) {
|
|
super(nextPolicy, options);
|
|
}
|
|
async sendRequest(request) {
|
|
let xMsHeaderName = "";
|
|
for (const header of request.headers.headersArray())
|
|
if (iEqual(header.name, HeaderConstants.X_MS_VERSION))
|
|
xMsHeaderName = header.name;
|
|
if (xMsHeaderName !== "")
|
|
request.headers.remove(xMsHeaderName);
|
|
return this._nextPolicy.sendRequest(request);
|
|
}
|
|
}
|
|
|
|
class BatchHeaderFilterPolicyFactory {
|
|
create(nextPolicy, options) {
|
|
return new BatchHeaderFilterPolicy(nextPolicy, options);
|
|
}
|
|
}
|
|
|
|
class BlobBatchClient {
|
|
constructor(url2, credentialOrPipeline, options) {
|
|
let pipeline;
|
|
if (isPipelineLike(credentialOrPipeline))
|
|
pipeline = credentialOrPipeline;
|
|
else if (!credentialOrPipeline)
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
else
|
|
pipeline = newPipeline(credentialOrPipeline, options);
|
|
const storageClientContext = new StorageClientContext(url2, pipeline.toServiceClientOptions());
|
|
const path = getURLPath(url2);
|
|
if (path && path !== "/")
|
|
this.serviceOrContainerContext = new Container(storageClientContext);
|
|
else
|
|
this.serviceOrContainerContext = new Service(storageClientContext);
|
|
}
|
|
createBatch() {
|
|
return new BlobBatch;
|
|
}
|
|
async deleteBlobs(urlsOrBlobClients, credentialOrOptions, options) {
|
|
const batch = new BlobBatch;
|
|
for (const urlOrBlobClient of urlsOrBlobClients)
|
|
if (typeof urlOrBlobClient === "string")
|
|
await batch.deleteBlob(urlOrBlobClient, credentialOrOptions, options);
|
|
else
|
|
await batch.deleteBlob(urlOrBlobClient, credentialOrOptions);
|
|
return this.submitBatch(batch);
|
|
}
|
|
async setBlobsAccessTier(urlsOrBlobClients, credentialOrTier, tierOrOptions, options) {
|
|
const batch = new BlobBatch;
|
|
for (const urlOrBlobClient of urlsOrBlobClients)
|
|
if (typeof urlOrBlobClient === "string")
|
|
await batch.setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions, options);
|
|
else
|
|
await batch.setBlobAccessTier(urlOrBlobClient, credentialOrTier, tierOrOptions);
|
|
return this.submitBatch(batch);
|
|
}
|
|
async submitBatch(batchRequest, options = {}) {
|
|
if (!batchRequest || batchRequest.getSubRequests().size === 0)
|
|
throw new RangeError("Batch request should contain one or more sub requests.");
|
|
const { span, updatedOptions } = createSpan("BlobBatchClient-submitBatch", options);
|
|
try {
|
|
const batchRequestBody = batchRequest.getHttpRequestBody();
|
|
const rawBatchResponse = await this.serviceOrContainerContext.submitBatch(utf8ByteLength(batchRequestBody), batchRequest.getMultiPartContentType(), batchRequestBody, Object.assign(Object.assign({}, options), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const batchResponseParser = new BatchResponseParser(rawBatchResponse, batchRequest.getSubRequests());
|
|
const responseSummary = await batchResponseParser.parseBatchResponse();
|
|
const res = {
|
|
_response: rawBatchResponse._response,
|
|
contentType: rawBatchResponse.contentType,
|
|
errorCode: rawBatchResponse.errorCode,
|
|
requestId: rawBatchResponse.requestId,
|
|
clientRequestId: rawBatchResponse.clientRequestId,
|
|
version: rawBatchResponse.version,
|
|
subResponses: responseSummary.subResponses,
|
|
subResponsesSucceededCount: responseSummary.subResponsesSucceededCount,
|
|
subResponsesFailedCount: responseSummary.subResponsesFailedCount
|
|
};
|
|
return res;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
}
|
|
|
|
class ContainerClient extends StorageClient {
|
|
constructor(urlOrConnectionString, credentialOrPipelineOrContainerName, options) {
|
|
let pipeline;
|
|
let url2;
|
|
options = options || {};
|
|
if (isPipelineLike(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = credentialOrPipelineOrContainerName;
|
|
} else if (coreHttp.isNode && credentialOrPipelineOrContainerName instanceof StorageSharedKeyCredential || credentialOrPipelineOrContainerName instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipelineOrContainerName)) {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = newPipeline(credentialOrPipelineOrContainerName, options);
|
|
} else if (!credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName !== "string") {
|
|
url2 = urlOrConnectionString;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else if (credentialOrPipelineOrContainerName && typeof credentialOrPipelineOrContainerName === "string") {
|
|
const containerName = credentialOrPipelineOrContainerName;
|
|
const extractedCreds = extractConnectionStringParts(urlOrConnectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
url2 = appendToURLPath(extractedCreds.url, encodeURIComponent(containerName));
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
pipeline = newPipeline(sharedKeyCredential, options);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
url2 = appendToURLPath(extractedCreds.url, encodeURIComponent(containerName)) + "?" + extractedCreds.accountSas;
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
} else
|
|
throw new Error("Expecting non-empty strings for containerName parameter");
|
|
super(url2, pipeline);
|
|
this._containerName = this.getContainerNameFromUrl();
|
|
this.containerContext = new Container(this.storageClientContext);
|
|
}
|
|
get containerName() {
|
|
return this._containerName;
|
|
}
|
|
async create(options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-create", options);
|
|
try {
|
|
return await this.containerContext.create(Object.assign(Object.assign({}, options), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async createIfNotExists(options = {}) {
|
|
var _a, _b;
|
|
const { span, updatedOptions } = createSpan("ContainerClient-createIfNotExists", options);
|
|
try {
|
|
const res = await this.create(updatedOptions);
|
|
return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
|
|
} catch (e) {
|
|
if (((_a = e.details) === null || _a === undefined ? undefined : _a.errorCode) === "ContainerAlreadyExists") {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when creating a container only if it does not already exist."
|
|
});
|
|
return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === undefined ? undefined : _b.parsedHeaders), { _response: e.response });
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async exists(options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-exists", options);
|
|
try {
|
|
await this.getProperties({
|
|
abortSignal: options.abortSignal,
|
|
tracingOptions: updatedOptions.tracingOptions
|
|
});
|
|
return true;
|
|
} catch (e) {
|
|
if (e.statusCode === 404) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when checking container existence"
|
|
});
|
|
return false;
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
getBlobClient(blobName) {
|
|
return new BlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);
|
|
}
|
|
getAppendBlobClient(blobName) {
|
|
return new AppendBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);
|
|
}
|
|
getBlockBlobClient(blobName) {
|
|
return new BlockBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);
|
|
}
|
|
getPageBlobClient(blobName) {
|
|
return new PageBlobClient(appendToURLPath(this.url, EscapePath(blobName)), this.pipeline);
|
|
}
|
|
async getProperties(options = {}) {
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
const { span, updatedOptions } = createSpan("ContainerClient-getProperties", options);
|
|
try {
|
|
return await this.containerContext.getProperties(Object.assign(Object.assign({ abortSignal: options.abortSignal }, options.conditions), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async delete(options = {}) {
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
const { span, updatedOptions } = createSpan("ContainerClient-delete", options);
|
|
try {
|
|
return await this.containerContext.delete(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async deleteIfExists(options = {}) {
|
|
var _a, _b;
|
|
const { span, updatedOptions } = createSpan("ContainerClient-deleteIfExists", options);
|
|
try {
|
|
const res = await this.delete(updatedOptions);
|
|
return Object.assign(Object.assign({ succeeded: true }, res), { _response: res._response });
|
|
} catch (e) {
|
|
if (((_a = e.details) === null || _a === undefined ? undefined : _a.errorCode) === "ContainerNotFound") {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: "Expected exception when deleting a container only if it exists."
|
|
});
|
|
return Object.assign(Object.assign({ succeeded: false }, (_b = e.response) === null || _b === undefined ? undefined : _b.parsedHeaders), { _response: e.response });
|
|
}
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setMetadata(metadata2, options = {}) {
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
if (options.conditions.ifUnmodifiedSince)
|
|
throw new RangeError("the IfUnmodifiedSince must have their default values because they are ignored by the blob service");
|
|
const { span, updatedOptions } = createSpan("ContainerClient-setMetadata", options);
|
|
try {
|
|
return await this.containerContext.setMetadata(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions, metadata: metadata2, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getAccessPolicy(options = {}) {
|
|
if (!options.conditions)
|
|
options.conditions = {};
|
|
const { span, updatedOptions } = createSpan("ContainerClient-getAccessPolicy", options);
|
|
try {
|
|
const response = await this.containerContext.getAccessPolicy(Object.assign({ abortSignal: options.abortSignal, leaseAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const res = {
|
|
_response: response._response,
|
|
blobPublicAccess: response.blobPublicAccess,
|
|
date: response.date,
|
|
etag: response.etag,
|
|
errorCode: response.errorCode,
|
|
lastModified: response.lastModified,
|
|
requestId: response.requestId,
|
|
clientRequestId: response.clientRequestId,
|
|
signedIdentifiers: [],
|
|
version: response.version
|
|
};
|
|
for (const identifier of response) {
|
|
let accessPolicy = undefined;
|
|
if (identifier.accessPolicy) {
|
|
accessPolicy = {
|
|
permissions: identifier.accessPolicy.permissions
|
|
};
|
|
if (identifier.accessPolicy.expiresOn)
|
|
accessPolicy.expiresOn = new Date(identifier.accessPolicy.expiresOn);
|
|
if (identifier.accessPolicy.startsOn)
|
|
accessPolicy.startsOn = new Date(identifier.accessPolicy.startsOn);
|
|
}
|
|
res.signedIdentifiers.push({
|
|
accessPolicy,
|
|
id: identifier.id
|
|
});
|
|
}
|
|
return res;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setAccessPolicy(access2, containerAcl2, options = {}) {
|
|
options.conditions = options.conditions || {};
|
|
const { span, updatedOptions } = createSpan("ContainerClient-setAccessPolicy", options);
|
|
try {
|
|
const acl = [];
|
|
for (const identifier of containerAcl2 || [])
|
|
acl.push({
|
|
accessPolicy: {
|
|
expiresOn: identifier.accessPolicy.expiresOn ? truncatedISO8061Date(identifier.accessPolicy.expiresOn) : "",
|
|
permissions: identifier.accessPolicy.permissions,
|
|
startsOn: identifier.accessPolicy.startsOn ? truncatedISO8061Date(identifier.accessPolicy.startsOn) : ""
|
|
},
|
|
id: identifier.id
|
|
});
|
|
return await this.containerContext.setAccessPolicy(Object.assign({ abortSignal: options.abortSignal, access: access2, containerAcl: acl, leaseAccessConditions: options.conditions, modifiedAccessConditions: options.conditions }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
getBlobLeaseClient(proposeLeaseId) {
|
|
return new BlobLeaseClient(this, proposeLeaseId);
|
|
}
|
|
async uploadBlockBlob(blobName, body2, contentLength2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-uploadBlockBlob", options);
|
|
try {
|
|
const blockBlobClient = this.getBlockBlobClient(blobName);
|
|
const response = await blockBlobClient.upload(body2, contentLength2, updatedOptions);
|
|
return {
|
|
blockBlobClient,
|
|
response
|
|
};
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async deleteBlob(blobName, options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-deleteBlob", options);
|
|
try {
|
|
let blobClient = this.getBlobClient(blobName);
|
|
if (options.versionId)
|
|
blobClient = blobClient.withVersion(options.versionId);
|
|
return await blobClient.delete(updatedOptions);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async listBlobFlatSegment(marker2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-listBlobFlatSegment", options);
|
|
try {
|
|
const response = await this.containerContext.listBlobFlatSegment(Object.assign(Object.assign({ marker: marker2 }, options), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobFlat(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {
|
|
const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });
|
|
return blobItem;
|
|
}) }) });
|
|
return wrappedResponse;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async listBlobHierarchySegment(delimiter2, marker2, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("ContainerClient-listBlobHierarchySegment", options);
|
|
try {
|
|
const response = await this.containerContext.listBlobHierarchySegment(delimiter2, Object.assign(Object.assign({ marker: marker2 }, options), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedResponse = Object.assign(Object.assign({}, response), { _response: Object.assign(Object.assign({}, response._response), { parsedBody: ConvertInternalResponseOfListBlobHierarchy(response._response.parsedBody) }), segment: Object.assign(Object.assign({}, response.segment), { blobItems: response.segment.blobItems.map((blobItemInteral) => {
|
|
const blobItem = Object.assign(Object.assign({}, blobItemInteral), { name: BlobNameToString(blobItemInteral.name), tags: toTags(blobItemInteral.blobTags), objectReplicationSourceProperties: parseObjectReplicationRecord(blobItemInteral.objectReplicationMetadata) });
|
|
return blobItem;
|
|
}), blobPrefixes: (_a = response.segment.blobPrefixes) === null || _a === undefined ? undefined : _a.map((blobPrefixInternal) => {
|
|
const blobPrefix = {
|
|
name: BlobNameToString(blobPrefixInternal.name)
|
|
};
|
|
return blobPrefix;
|
|
}) }) });
|
|
return wrappedResponse;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
listSegments(marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listSegments_1() {
|
|
let listBlobsFlatSegmentResponse;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
listBlobsFlatSegmentResponse = yield tslib.__await(this.listBlobFlatSegment(marker2, options));
|
|
marker2 = listBlobsFlatSegmentResponse.continuationToken;
|
|
yield yield tslib.__await(yield tslib.__await(listBlobsFlatSegmentResponse));
|
|
} while (marker2);
|
|
});
|
|
}
|
|
listItems(options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listItems_1() {
|
|
var e_1, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.listSegments(marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const listBlobsFlatSegmentResponse = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(listBlobsFlatSegmentResponse.segment.blobItems)));
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_1)
|
|
throw e_1.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
listBlobsFlat(options = {}) {
|
|
const include2 = [];
|
|
if (options.includeCopy)
|
|
include2.push("copy");
|
|
if (options.includeDeleted)
|
|
include2.push("deleted");
|
|
if (options.includeMetadata)
|
|
include2.push("metadata");
|
|
if (options.includeSnapshots)
|
|
include2.push("snapshots");
|
|
if (options.includeVersions)
|
|
include2.push("versions");
|
|
if (options.includeUncommitedBlobs)
|
|
include2.push("uncommittedblobs");
|
|
if (options.includeTags)
|
|
include2.push("tags");
|
|
if (options.includeDeletedWithVersions)
|
|
include2.push("deletedwithversions");
|
|
if (options.includeImmutabilityPolicy)
|
|
include2.push("immutabilitypolicy");
|
|
if (options.includeLegalHold)
|
|
include2.push("legalhold");
|
|
if (options.prefix === "")
|
|
options.prefix = undefined;
|
|
const updatedOptions = Object.assign(Object.assign({}, options), include2.length > 0 ? { include: include2 } : {});
|
|
const iter = this.listItems(updatedOptions);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.listSegments(settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, updatedOptions));
|
|
}
|
|
};
|
|
}
|
|
listHierarchySegments(delimiter2, marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listHierarchySegments_1() {
|
|
let listBlobsHierarchySegmentResponse;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
listBlobsHierarchySegmentResponse = yield tslib.__await(this.listBlobHierarchySegment(delimiter2, marker2, options));
|
|
marker2 = listBlobsHierarchySegmentResponse.continuationToken;
|
|
yield yield tslib.__await(yield tslib.__await(listBlobsHierarchySegmentResponse));
|
|
} while (marker2);
|
|
});
|
|
}
|
|
listItemsByHierarchy(delimiter2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listItemsByHierarchy_1() {
|
|
var e_2, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.listHierarchySegments(delimiter2, marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const listBlobsHierarchySegmentResponse = _c.value;
|
|
const segment = listBlobsHierarchySegmentResponse.segment;
|
|
if (segment.blobPrefixes)
|
|
for (const prefix2 of segment.blobPrefixes)
|
|
yield yield tslib.__await(Object.assign({ kind: "prefix" }, prefix2));
|
|
for (const blob of segment.blobItems)
|
|
yield yield tslib.__await(Object.assign({ kind: "blob" }, blob));
|
|
}
|
|
} catch (e_2_1) {
|
|
e_2 = { error: e_2_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_2)
|
|
throw e_2.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
listBlobsByHierarchy(delimiter2, options = {}) {
|
|
if (delimiter2 === "")
|
|
throw new RangeError("delimiter should contain one or more characters");
|
|
const include2 = [];
|
|
if (options.includeCopy)
|
|
include2.push("copy");
|
|
if (options.includeDeleted)
|
|
include2.push("deleted");
|
|
if (options.includeMetadata)
|
|
include2.push("metadata");
|
|
if (options.includeSnapshots)
|
|
include2.push("snapshots");
|
|
if (options.includeVersions)
|
|
include2.push("versions");
|
|
if (options.includeUncommitedBlobs)
|
|
include2.push("uncommittedblobs");
|
|
if (options.includeTags)
|
|
include2.push("tags");
|
|
if (options.includeDeletedWithVersions)
|
|
include2.push("deletedwithversions");
|
|
if (options.includeImmutabilityPolicy)
|
|
include2.push("immutabilitypolicy");
|
|
if (options.includeLegalHold)
|
|
include2.push("legalhold");
|
|
if (options.prefix === "")
|
|
options.prefix = undefined;
|
|
const updatedOptions = Object.assign(Object.assign({}, options), include2.length > 0 ? { include: include2 } : {});
|
|
const iter = this.listItemsByHierarchy(delimiter2, updatedOptions);
|
|
return {
|
|
async next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.listHierarchySegments(delimiter2, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, updatedOptions));
|
|
}
|
|
};
|
|
}
|
|
async findBlobsByTagsSegment(tagFilterSqlExpression, marker2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("ContainerClient-findBlobsByTagsSegment", options);
|
|
try {
|
|
const response = await this.containerContext.filterBlobs(Object.assign({ abortSignal: options.abortSignal, where: tagFilterSqlExpression, marker: marker2, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, blobs: response.blobs.map((blob) => {
|
|
var _a;
|
|
let tagValue = "";
|
|
if (((_a = blob.tags) === null || _a === undefined ? undefined : _a.blobTagSet.length) === 1)
|
|
tagValue = blob.tags.blobTagSet[0].value;
|
|
return Object.assign(Object.assign({}, blob), { tags: toTags(blob.tags), tagValue });
|
|
}) });
|
|
return wrappedResponse;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
findBlobsByTagsSegments(tagFilterSqlExpression, marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* findBlobsByTagsSegments_1() {
|
|
let response;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
response = yield tslib.__await(this.findBlobsByTagsSegment(tagFilterSqlExpression, marker2, options));
|
|
response.blobs = response.blobs || [];
|
|
marker2 = response.continuationToken;
|
|
yield yield tslib.__await(response);
|
|
} while (marker2);
|
|
});
|
|
}
|
|
findBlobsByTagsItems(tagFilterSqlExpression, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* findBlobsByTagsItems_1() {
|
|
var e_3, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.findBlobsByTagsSegments(tagFilterSqlExpression, marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const segment = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(segment.blobs)));
|
|
}
|
|
} catch (e_3_1) {
|
|
e_3 = { error: e_3_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_3)
|
|
throw e_3.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
findBlobsByTags(tagFilterSqlExpression, options = {}) {
|
|
const listSegmentOptions = Object.assign({}, options);
|
|
const iter = this.findBlobsByTagsItems(tagFilterSqlExpression, listSegmentOptions);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.findBlobsByTagsSegments(tagFilterSqlExpression, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, listSegmentOptions));
|
|
}
|
|
};
|
|
}
|
|
getContainerNameFromUrl() {
|
|
let containerName;
|
|
try {
|
|
const parsedUrl = coreHttp.URLBuilder.parse(this.url);
|
|
if (parsedUrl.getHost().split(".")[1] === "blob")
|
|
containerName = parsedUrl.getPath().split("/")[1];
|
|
else if (isIpEndpointStyle(parsedUrl))
|
|
containerName = parsedUrl.getPath().split("/")[2];
|
|
else
|
|
containerName = parsedUrl.getPath().split("/")[1];
|
|
containerName = decodeURIComponent(containerName);
|
|
if (!containerName)
|
|
throw new Error("Provided containerName is invalid.");
|
|
return containerName;
|
|
} catch (error) {
|
|
throw new Error("Unable to extract containerName with provided information.");
|
|
}
|
|
}
|
|
generateSasUrl(options) {
|
|
return new Promise((resolve) => {
|
|
if (!(this.credential instanceof StorageSharedKeyCredential))
|
|
throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
|
|
const sas = generateBlobSASQueryParameters(Object.assign({ containerName: this._containerName }, options), this.credential).toString();
|
|
resolve(appendToURLQuery(this.url, sas));
|
|
});
|
|
}
|
|
getBlobBatchClient() {
|
|
return new BlobBatchClient(this.url, this.pipeline);
|
|
}
|
|
}
|
|
|
|
class AccountSASPermissions {
|
|
constructor() {
|
|
this.read = false;
|
|
this.write = false;
|
|
this.delete = false;
|
|
this.deleteVersion = false;
|
|
this.list = false;
|
|
this.add = false;
|
|
this.create = false;
|
|
this.update = false;
|
|
this.process = false;
|
|
this.tag = false;
|
|
this.filter = false;
|
|
this.setImmutabilityPolicy = false;
|
|
this.permanentDelete = false;
|
|
}
|
|
static parse(permissions) {
|
|
const accountSASPermissions = new AccountSASPermissions;
|
|
for (const c of permissions)
|
|
switch (c) {
|
|
case "r":
|
|
accountSASPermissions.read = true;
|
|
break;
|
|
case "w":
|
|
accountSASPermissions.write = true;
|
|
break;
|
|
case "d":
|
|
accountSASPermissions.delete = true;
|
|
break;
|
|
case "x":
|
|
accountSASPermissions.deleteVersion = true;
|
|
break;
|
|
case "l":
|
|
accountSASPermissions.list = true;
|
|
break;
|
|
case "a":
|
|
accountSASPermissions.add = true;
|
|
break;
|
|
case "c":
|
|
accountSASPermissions.create = true;
|
|
break;
|
|
case "u":
|
|
accountSASPermissions.update = true;
|
|
break;
|
|
case "p":
|
|
accountSASPermissions.process = true;
|
|
break;
|
|
case "t":
|
|
accountSASPermissions.tag = true;
|
|
break;
|
|
case "f":
|
|
accountSASPermissions.filter = true;
|
|
break;
|
|
case "i":
|
|
accountSASPermissions.setImmutabilityPolicy = true;
|
|
break;
|
|
case "y":
|
|
accountSASPermissions.permanentDelete = true;
|
|
break;
|
|
default:
|
|
throw new RangeError(`Invalid permission character: ${c}`);
|
|
}
|
|
return accountSASPermissions;
|
|
}
|
|
static from(permissionLike) {
|
|
const accountSASPermissions = new AccountSASPermissions;
|
|
if (permissionLike.read)
|
|
accountSASPermissions.read = true;
|
|
if (permissionLike.write)
|
|
accountSASPermissions.write = true;
|
|
if (permissionLike.delete)
|
|
accountSASPermissions.delete = true;
|
|
if (permissionLike.deleteVersion)
|
|
accountSASPermissions.deleteVersion = true;
|
|
if (permissionLike.filter)
|
|
accountSASPermissions.filter = true;
|
|
if (permissionLike.tag)
|
|
accountSASPermissions.tag = true;
|
|
if (permissionLike.list)
|
|
accountSASPermissions.list = true;
|
|
if (permissionLike.add)
|
|
accountSASPermissions.add = true;
|
|
if (permissionLike.create)
|
|
accountSASPermissions.create = true;
|
|
if (permissionLike.update)
|
|
accountSASPermissions.update = true;
|
|
if (permissionLike.process)
|
|
accountSASPermissions.process = true;
|
|
if (permissionLike.setImmutabilityPolicy)
|
|
accountSASPermissions.setImmutabilityPolicy = true;
|
|
if (permissionLike.permanentDelete)
|
|
accountSASPermissions.permanentDelete = true;
|
|
return accountSASPermissions;
|
|
}
|
|
toString() {
|
|
const permissions = [];
|
|
if (this.read)
|
|
permissions.push("r");
|
|
if (this.write)
|
|
permissions.push("w");
|
|
if (this.delete)
|
|
permissions.push("d");
|
|
if (this.deleteVersion)
|
|
permissions.push("x");
|
|
if (this.filter)
|
|
permissions.push("f");
|
|
if (this.tag)
|
|
permissions.push("t");
|
|
if (this.list)
|
|
permissions.push("l");
|
|
if (this.add)
|
|
permissions.push("a");
|
|
if (this.create)
|
|
permissions.push("c");
|
|
if (this.update)
|
|
permissions.push("u");
|
|
if (this.process)
|
|
permissions.push("p");
|
|
if (this.setImmutabilityPolicy)
|
|
permissions.push("i");
|
|
if (this.permanentDelete)
|
|
permissions.push("y");
|
|
return permissions.join("");
|
|
}
|
|
}
|
|
|
|
class AccountSASResourceTypes {
|
|
constructor() {
|
|
this.service = false;
|
|
this.container = false;
|
|
this.object = false;
|
|
}
|
|
static parse(resourceTypes) {
|
|
const accountSASResourceTypes = new AccountSASResourceTypes;
|
|
for (const c of resourceTypes)
|
|
switch (c) {
|
|
case "s":
|
|
accountSASResourceTypes.service = true;
|
|
break;
|
|
case "c":
|
|
accountSASResourceTypes.container = true;
|
|
break;
|
|
case "o":
|
|
accountSASResourceTypes.object = true;
|
|
break;
|
|
default:
|
|
throw new RangeError(`Invalid resource type: ${c}`);
|
|
}
|
|
return accountSASResourceTypes;
|
|
}
|
|
toString() {
|
|
const resourceTypes = [];
|
|
if (this.service)
|
|
resourceTypes.push("s");
|
|
if (this.container)
|
|
resourceTypes.push("c");
|
|
if (this.object)
|
|
resourceTypes.push("o");
|
|
return resourceTypes.join("");
|
|
}
|
|
}
|
|
|
|
class AccountSASServices {
|
|
constructor() {
|
|
this.blob = false;
|
|
this.file = false;
|
|
this.queue = false;
|
|
this.table = false;
|
|
}
|
|
static parse(services) {
|
|
const accountSASServices = new AccountSASServices;
|
|
for (const c of services)
|
|
switch (c) {
|
|
case "b":
|
|
accountSASServices.blob = true;
|
|
break;
|
|
case "f":
|
|
accountSASServices.file = true;
|
|
break;
|
|
case "q":
|
|
accountSASServices.queue = true;
|
|
break;
|
|
case "t":
|
|
accountSASServices.table = true;
|
|
break;
|
|
default:
|
|
throw new RangeError(`Invalid service character: ${c}`);
|
|
}
|
|
return accountSASServices;
|
|
}
|
|
toString() {
|
|
const services = [];
|
|
if (this.blob)
|
|
services.push("b");
|
|
if (this.table)
|
|
services.push("t");
|
|
if (this.queue)
|
|
services.push("q");
|
|
if (this.file)
|
|
services.push("f");
|
|
return services.join("");
|
|
}
|
|
}
|
|
|
|
class BlobServiceClient extends StorageClient {
|
|
constructor(url2, credentialOrPipeline, options) {
|
|
let pipeline;
|
|
if (isPipelineLike(credentialOrPipeline))
|
|
pipeline = credentialOrPipeline;
|
|
else if (coreHttp.isNode && credentialOrPipeline instanceof StorageSharedKeyCredential || credentialOrPipeline instanceof AnonymousCredential || coreHttp.isTokenCredential(credentialOrPipeline))
|
|
pipeline = newPipeline(credentialOrPipeline, options);
|
|
else
|
|
pipeline = newPipeline(new AnonymousCredential, options);
|
|
super(url2, pipeline);
|
|
this.serviceContext = new Service(this.storageClientContext);
|
|
}
|
|
static fromConnectionString(connectionString, options) {
|
|
options = options || {};
|
|
const extractedCreds = extractConnectionStringParts(connectionString);
|
|
if (extractedCreds.kind === "AccountConnString")
|
|
if (coreHttp.isNode) {
|
|
const sharedKeyCredential = new StorageSharedKeyCredential(extractedCreds.accountName, extractedCreds.accountKey);
|
|
if (!options.proxyOptions)
|
|
options.proxyOptions = coreHttp.getDefaultProxySettings(extractedCreds.proxyUri);
|
|
const pipeline = newPipeline(sharedKeyCredential, options);
|
|
return new BlobServiceClient(extractedCreds.url, pipeline);
|
|
} else
|
|
throw new Error("Account connection string is only supported in Node.js environment");
|
|
else if (extractedCreds.kind === "SASConnString") {
|
|
const pipeline = newPipeline(new AnonymousCredential, options);
|
|
return new BlobServiceClient(extractedCreds.url + "?" + extractedCreds.accountSas, pipeline);
|
|
} else
|
|
throw new Error("Connection string must be either an Account connection string or a SAS connection string");
|
|
}
|
|
getContainerClient(containerName) {
|
|
return new ContainerClient(appendToURLPath(this.url, encodeURIComponent(containerName)), this.pipeline);
|
|
}
|
|
async createContainer(containerName, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-createContainer", options);
|
|
try {
|
|
const containerClient = this.getContainerClient(containerName);
|
|
const containerCreateResponse = await containerClient.create(updatedOptions);
|
|
return {
|
|
containerClient,
|
|
containerCreateResponse
|
|
};
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async deleteContainer(containerName, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-deleteContainer", options);
|
|
try {
|
|
const containerClient = this.getContainerClient(containerName);
|
|
return await containerClient.delete(updatedOptions);
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async undeleteContainer(deletedContainerName2, deletedContainerVersion2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-undeleteContainer", options);
|
|
try {
|
|
const containerClient = this.getContainerClient(options.destinationContainerName || deletedContainerName2);
|
|
const containerContext = new Container(containerClient["storageClientContext"]);
|
|
const containerUndeleteResponse = await containerContext.restore(Object.assign({
|
|
deletedContainerName: deletedContainerName2,
|
|
deletedContainerVersion: deletedContainerVersion2
|
|
}, updatedOptions));
|
|
return { containerClient, containerUndeleteResponse };
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async renameContainer(sourceContainerName2, destinationContainerName, options = {}) {
|
|
var _a;
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-renameContainer", options);
|
|
try {
|
|
const containerClient = this.getContainerClient(destinationContainerName);
|
|
const containerContext = new Container(containerClient["storageClientContext"]);
|
|
const containerRenameResponse = await containerContext.rename(sourceContainerName2, Object.assign(Object.assign({}, updatedOptions), { sourceLeaseId: (_a = options.sourceCondition) === null || _a === undefined ? undefined : _a.leaseId }));
|
|
return { containerClient, containerRenameResponse };
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getProperties(options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-getProperties", options);
|
|
try {
|
|
return await this.serviceContext.getProperties(Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async setProperties(properties, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-setProperties", options);
|
|
try {
|
|
return await this.serviceContext.setProperties(properties, Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getStatistics(options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-getStatistics", options);
|
|
try {
|
|
return await this.serviceContext.getStatistics(Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async getAccountInfo(options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-getAccountInfo", options);
|
|
try {
|
|
return await this.serviceContext.getAccountInfo(Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async listContainersSegment(marker2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-listContainersSegment", options);
|
|
try {
|
|
return await this.serviceContext.listContainersSegment(Object.assign(Object.assign(Object.assign({ abortSignal: options.abortSignal, marker: marker2 }, options), { include: typeof options.include === "string" ? [options.include] : options.include }), convertTracingToRequestOptionsBase(updatedOptions)));
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
async findBlobsByTagsSegment(tagFilterSqlExpression, marker2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-findBlobsByTagsSegment", options);
|
|
try {
|
|
const response = await this.serviceContext.filterBlobs(Object.assign({ abortSignal: options.abortSignal, where: tagFilterSqlExpression, marker: marker2, maxPageSize: options.maxPageSize }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const wrappedResponse = Object.assign(Object.assign({}, response), { _response: response._response, blobs: response.blobs.map((blob) => {
|
|
var _a;
|
|
let tagValue = "";
|
|
if (((_a = blob.tags) === null || _a === undefined ? undefined : _a.blobTagSet.length) === 1)
|
|
tagValue = blob.tags.blobTagSet[0].value;
|
|
return Object.assign(Object.assign({}, blob), { tags: toTags(blob.tags), tagValue });
|
|
}) });
|
|
return wrappedResponse;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
findBlobsByTagsSegments(tagFilterSqlExpression, marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* findBlobsByTagsSegments_1() {
|
|
let response;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
response = yield tslib.__await(this.findBlobsByTagsSegment(tagFilterSqlExpression, marker2, options));
|
|
response.blobs = response.blobs || [];
|
|
marker2 = response.continuationToken;
|
|
yield yield tslib.__await(response);
|
|
} while (marker2);
|
|
});
|
|
}
|
|
findBlobsByTagsItems(tagFilterSqlExpression, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* findBlobsByTagsItems_1() {
|
|
var e_1, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.findBlobsByTagsSegments(tagFilterSqlExpression, marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const segment = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(segment.blobs)));
|
|
}
|
|
} catch (e_1_1) {
|
|
e_1 = { error: e_1_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_1)
|
|
throw e_1.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
findBlobsByTags(tagFilterSqlExpression, options = {}) {
|
|
const listSegmentOptions = Object.assign({}, options);
|
|
const iter = this.findBlobsByTagsItems(tagFilterSqlExpression, listSegmentOptions);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.findBlobsByTagsSegments(tagFilterSqlExpression, settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, listSegmentOptions));
|
|
}
|
|
};
|
|
}
|
|
listSegments(marker2, options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listSegments_1() {
|
|
let listContainersSegmentResponse;
|
|
if (!!marker2 || marker2 === undefined)
|
|
do {
|
|
listContainersSegmentResponse = yield tslib.__await(this.listContainersSegment(marker2, options));
|
|
listContainersSegmentResponse.containerItems = listContainersSegmentResponse.containerItems || [];
|
|
marker2 = listContainersSegmentResponse.continuationToken;
|
|
yield yield tslib.__await(yield tslib.__await(listContainersSegmentResponse));
|
|
} while (marker2);
|
|
});
|
|
}
|
|
listItems(options = {}) {
|
|
return tslib.__asyncGenerator(this, arguments, function* listItems_1() {
|
|
var e_2, _a;
|
|
let marker2;
|
|
try {
|
|
for (var _b = tslib.__asyncValues(this.listSegments(marker2, options)), _c;_c = yield tslib.__await(_b.next()), !_c.done; ) {
|
|
const segment = _c.value;
|
|
yield tslib.__await(yield* tslib.__asyncDelegator(tslib.__asyncValues(segment.containerItems)));
|
|
}
|
|
} catch (e_2_1) {
|
|
e_2 = { error: e_2_1 };
|
|
} finally {
|
|
try {
|
|
if (_c && !_c.done && (_a = _b.return))
|
|
yield tslib.__await(_a.call(_b));
|
|
} finally {
|
|
if (e_2)
|
|
throw e_2.error;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
listContainers(options = {}) {
|
|
if (options.prefix === "")
|
|
options.prefix = undefined;
|
|
const include2 = [];
|
|
if (options.includeDeleted)
|
|
include2.push("deleted");
|
|
if (options.includeMetadata)
|
|
include2.push("metadata");
|
|
if (options.includeSystem)
|
|
include2.push("system");
|
|
const listSegmentOptions = Object.assign(Object.assign({}, options), include2.length > 0 ? { include: include2 } : {});
|
|
const iter = this.listItems(listSegmentOptions);
|
|
return {
|
|
next() {
|
|
return iter.next();
|
|
},
|
|
[Symbol.asyncIterator]() {
|
|
return this;
|
|
},
|
|
byPage: (settings = {}) => {
|
|
return this.listSegments(settings.continuationToken, Object.assign({ maxPageSize: settings.maxPageSize }, listSegmentOptions));
|
|
}
|
|
};
|
|
}
|
|
async getUserDelegationKey(startsOn, expiresOn2, options = {}) {
|
|
const { span, updatedOptions } = createSpan("BlobServiceClient-getUserDelegationKey", options);
|
|
try {
|
|
const response = await this.serviceContext.getUserDelegationKey({
|
|
startsOn: truncatedISO8061Date(startsOn, false),
|
|
expiresOn: truncatedISO8061Date(expiresOn2, false)
|
|
}, Object.assign({ abortSignal: options.abortSignal }, convertTracingToRequestOptionsBase(updatedOptions)));
|
|
const userDelegationKey = {
|
|
signedObjectId: response.signedObjectId,
|
|
signedTenantId: response.signedTenantId,
|
|
signedStartsOn: new Date(response.signedStartsOn),
|
|
signedExpiresOn: new Date(response.signedExpiresOn),
|
|
signedService: response.signedService,
|
|
signedVersion: response.signedVersion,
|
|
value: response.value
|
|
};
|
|
const res = Object.assign({ _response: response._response, requestId: response.requestId, clientRequestId: response.clientRequestId, version: response.version, date: response.date, errorCode: response.errorCode }, userDelegationKey);
|
|
return res;
|
|
} catch (e) {
|
|
span.setStatus({
|
|
code: coreTracing.SpanStatusCode.ERROR,
|
|
message: e.message
|
|
});
|
|
throw e;
|
|
} finally {
|
|
span.end();
|
|
}
|
|
}
|
|
getBlobBatchClient() {
|
|
return new BlobBatchClient(this.url, this.pipeline);
|
|
}
|
|
generateAccountSasUrl(expiresOn2, permissions = AccountSASPermissions.parse("r"), resourceTypes = "sco", options = {}) {
|
|
if (!(this.credential instanceof StorageSharedKeyCredential))
|
|
throw RangeError("Can only generate the account SAS when the client is initialized with a shared key credential");
|
|
if (expiresOn2 === undefined) {
|
|
const now = new Date;
|
|
expiresOn2 = new Date(now.getTime() + 3600 * 1000);
|
|
}
|
|
const sas = generateAccountSASQueryParameters(Object.assign({
|
|
permissions,
|
|
expiresOn: expiresOn2,
|
|
resourceTypes,
|
|
services: AccountSASServices.parse("b").toString()
|
|
}, options), this.credential).toString();
|
|
return appendToURLQuery(this.url, sas);
|
|
}
|
|
}
|
|
exports.KnownEncryptionAlgorithmType = undefined;
|
|
(function(KnownEncryptionAlgorithmType) {
|
|
KnownEncryptionAlgorithmType["AES256"] = "AES256";
|
|
})(exports.KnownEncryptionAlgorithmType || (exports.KnownEncryptionAlgorithmType = {}));
|
|
Object.defineProperty(exports, "BaseRequestPolicy", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.BaseRequestPolicy;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "HttpHeaders", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.HttpHeaders;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "RequestPolicyOptions", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.RequestPolicyOptions;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "RestError", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.RestError;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "WebResource", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.WebResource;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "deserializationPolicy", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return coreHttp.deserializationPolicy;
|
|
}
|
|
});
|
|
exports.AccountSASPermissions = AccountSASPermissions;
|
|
exports.AccountSASResourceTypes = AccountSASResourceTypes;
|
|
exports.AccountSASServices = AccountSASServices;
|
|
exports.AnonymousCredential = AnonymousCredential;
|
|
exports.AnonymousCredentialPolicy = AnonymousCredentialPolicy;
|
|
exports.AppendBlobClient = AppendBlobClient;
|
|
exports.BlobBatch = BlobBatch;
|
|
exports.BlobBatchClient = BlobBatchClient;
|
|
exports.BlobClient = BlobClient;
|
|
exports.BlobLeaseClient = BlobLeaseClient;
|
|
exports.BlobSASPermissions = BlobSASPermissions;
|
|
exports.BlobServiceClient = BlobServiceClient;
|
|
exports.BlockBlobClient = BlockBlobClient;
|
|
exports.ContainerClient = ContainerClient;
|
|
exports.ContainerSASPermissions = ContainerSASPermissions;
|
|
exports.Credential = Credential;
|
|
exports.CredentialPolicy = CredentialPolicy;
|
|
exports.PageBlobClient = PageBlobClient;
|
|
exports.Pipeline = Pipeline;
|
|
exports.SASQueryParameters = SASQueryParameters;
|
|
exports.StorageBrowserPolicy = StorageBrowserPolicy;
|
|
exports.StorageBrowserPolicyFactory = StorageBrowserPolicyFactory;
|
|
exports.StorageOAuthScopes = StorageOAuthScopes;
|
|
exports.StorageRetryPolicy = StorageRetryPolicy;
|
|
exports.StorageRetryPolicyFactory = StorageRetryPolicyFactory;
|
|
exports.StorageSharedKeyCredential = StorageSharedKeyCredential;
|
|
exports.StorageSharedKeyCredentialPolicy = StorageSharedKeyCredentialPolicy;
|
|
exports.generateAccountSASQueryParameters = generateAccountSASQueryParameters;
|
|
exports.generateBlobSASQueryParameters = generateBlobSASQueryParameters;
|
|
exports.isPipelineLike = isPipelineLike;
|
|
exports.logger = logger;
|
|
exports.newPipeline = newPipeline;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/requestUtils.js
|
|
var require_requestUtils = __commonJS((exports) => {
|
|
var isSuccessStatusCode = function(statusCode) {
|
|
if (!statusCode)
|
|
return false;
|
|
return statusCode >= 200 && statusCode < 300;
|
|
};
|
|
var isServerErrorStatusCode = function(statusCode) {
|
|
if (!statusCode)
|
|
return true;
|
|
return statusCode >= 500;
|
|
};
|
|
var isRetryableStatusCode = function(statusCode) {
|
|
if (!statusCode)
|
|
return false;
|
|
const retryableStatusCodes = [
|
|
http_client_1.HttpCodes.BadGateway,
|
|
http_client_1.HttpCodes.ServiceUnavailable,
|
|
http_client_1.HttpCodes.GatewayTimeout
|
|
];
|
|
return retryableStatusCodes.includes(statusCode);
|
|
};
|
|
var sleep = function(milliseconds) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
return new Promise((resolve) => setTimeout(resolve, milliseconds));
|
|
});
|
|
};
|
|
var retry = function(name, method, getStatusCode, maxAttempts = constants_1.DefaultRetryAttempts, delay = constants_1.DefaultRetryDelay, onError = undefined) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
let errorMessage = "";
|
|
let attempt = 1;
|
|
while (attempt <= maxAttempts) {
|
|
let response = undefined;
|
|
let statusCode = undefined;
|
|
let isRetryable = false;
|
|
try {
|
|
response = yield method();
|
|
} catch (error) {
|
|
if (onError)
|
|
response = onError(error);
|
|
isRetryable = true;
|
|
errorMessage = error.message;
|
|
}
|
|
if (response) {
|
|
statusCode = getStatusCode(response);
|
|
if (!isServerErrorStatusCode(statusCode))
|
|
return response;
|
|
}
|
|
if (statusCode) {
|
|
isRetryable = isRetryableStatusCode(statusCode);
|
|
errorMessage = `Cache service responded with ${statusCode}`;
|
|
}
|
|
core.debug(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
|
|
if (!isRetryable) {
|
|
core.debug(`${name} - Error is not retryable`);
|
|
break;
|
|
}
|
|
yield sleep(delay);
|
|
attempt++;
|
|
}
|
|
throw Error(`${name} failed: ${errorMessage}`);
|
|
});
|
|
};
|
|
var retryTypedResponse = function(name, method, maxAttempts = constants_1.DefaultRetryAttempts, delay = constants_1.DefaultRetryDelay) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
return yield retry(name, method, (response) => response.statusCode, maxAttempts, delay, (error) => {
|
|
if (error instanceof http_client_1.HttpClientError)
|
|
return {
|
|
statusCode: error.statusCode,
|
|
result: null,
|
|
headers: {},
|
|
error
|
|
};
|
|
else
|
|
return;
|
|
});
|
|
});
|
|
};
|
|
var retryHttpClientResponse = function(name, method, maxAttempts = constants_1.DefaultRetryAttempts, delay = constants_1.DefaultRetryDelay) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
return yield retry(name, method, (response) => response.message.statusCode, maxAttempts, delay);
|
|
});
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter2 = exports && exports.__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.retryHttpClientResponse = exports.retryTypedResponse = exports.retry = exports.isRetryableStatusCode = exports.isServerErrorStatusCode = exports.isSuccessStatusCode = undefined;
|
|
var core = __importStar2(require_core());
|
|
var http_client_1 = require_lib();
|
|
var constants_1 = require_constants();
|
|
exports.isSuccessStatusCode = isSuccessStatusCode;
|
|
exports.isServerErrorStatusCode = isServerErrorStatusCode;
|
|
exports.isRetryableStatusCode = isRetryableStatusCode;
|
|
exports.retry = retry;
|
|
exports.retryTypedResponse = retryTypedResponse;
|
|
exports.retryHttpClientResponse = retryHttpClientResponse;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/downloadUtils.js
|
|
var require_downloadUtils = __commonJS((exports) => {
|
|
var pipeResponseToStream = function(response, output) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const pipeline = util.promisify(stream.pipeline);
|
|
yield pipeline(response.message, output);
|
|
});
|
|
};
|
|
var downloadCacheHttpClient = function(archiveLocation, archivePath) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const writeStream = fs.createWriteStream(archivePath);
|
|
const httpClient = new http_client_1.HttpClient("actions/cache");
|
|
const downloadResponse = yield (0, requestUtils_1.retryHttpClientResponse)("downloadCache", () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.get(archiveLocation);
|
|
}));
|
|
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);
|
|
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");
|
|
});
|
|
};
|
|
var downloadCacheStorageSDK = function(archiveLocation, archivePath, options) {
|
|
var _a;
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const client = new storage_blob_1.BlockBlobClient(archiveLocation, undefined, {
|
|
retryOptions: {
|
|
tryTimeoutInMs: options.timeoutInMs
|
|
}
|
|
});
|
|
const properties = yield client.getProperties();
|
|
const contentLength = (_a = properties.contentLength) !== null && _a !== undefined ? _a : -1;
|
|
if (contentLength < 0) {
|
|
core.debug("Unable to determine content length, downloading file with http-client...");
|
|
yield downloadCacheHttpClient(archiveLocation, archivePath);
|
|
} else {
|
|
const maxSegmentSize = Math.min(134217728, 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);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter2 = exports && exports.__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.downloadCacheStorageSDK = exports.downloadCacheHttpClient = exports.DownloadProgress = undefined;
|
|
var core = __importStar2(require_core());
|
|
var http_client_1 = require_lib();
|
|
var storage_blob_1 = require_dist9();
|
|
var buffer = __importStar2(__require("buffer"));
|
|
var fs = __importStar2(__require("fs"));
|
|
var stream = __importStar2(__require("stream"));
|
|
var util = __importStar2(__require("util"));
|
|
var utils = __importStar2(require_cacheUtils());
|
|
var constants_1 = require_constants();
|
|
var requestUtils_1 = require_requestUtils();
|
|
var abort_controller_1 = require_dist();
|
|
|
|
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();
|
|
}
|
|
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}...`);
|
|
}
|
|
setReceivedBytes(receivedBytes) {
|
|
this.receivedBytes = receivedBytes;
|
|
}
|
|
getTransferredBytes() {
|
|
return this.segmentOffset + this.receivedBytes;
|
|
}
|
|
isDone() {
|
|
return this.getTransferredBytes() === this.contentLength;
|
|
}
|
|
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;
|
|
}
|
|
onProgress() {
|
|
return (progress) => {
|
|
this.setReceivedBytes(progress.loadedBytes);
|
|
};
|
|
}
|
|
startDisplayTimer(delayInMs = 1000) {
|
|
const displayCallback = () => {
|
|
this.display();
|
|
if (!this.isDone())
|
|
this.timeoutHandle = setTimeout(displayCallback, delayInMs);
|
|
};
|
|
this.timeoutHandle = setTimeout(displayCallback, delayInMs);
|
|
}
|
|
stopDisplayTimer() {
|
|
if (this.timeoutHandle) {
|
|
clearTimeout(this.timeoutHandle);
|
|
this.timeoutHandle = undefined;
|
|
}
|
|
this.display();
|
|
}
|
|
}
|
|
exports.DownloadProgress = DownloadProgress;
|
|
exports.downloadCacheHttpClient = downloadCacheHttpClient;
|
|
exports.downloadCacheStorageSDK = downloadCacheStorageSDK;
|
|
var promiseWithTimeout = (timeoutMs, promise) => __awaiter2(undefined, undefined, undefined, function* () {
|
|
let timeoutHandle;
|
|
const timeoutPromise = new Promise((resolve) => {
|
|
timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
|
|
});
|
|
return Promise.race([promise, timeoutPromise]).then((result) => {
|
|
clearTimeout(timeoutHandle);
|
|
return result;
|
|
});
|
|
});
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/options.js
|
|
var require_options = __commonJS((exports) => {
|
|
var getUploadOptions = function(copy) {
|
|
const result = {
|
|
uploadConcurrency: 4,
|
|
uploadChunkSize: 32 * 1024 * 1024
|
|
};
|
|
if (copy) {
|
|
if (typeof copy.uploadConcurrency === "number")
|
|
result.uploadConcurrency = copy.uploadConcurrency;
|
|
if (typeof copy.uploadChunkSize === "number")
|
|
result.uploadChunkSize = copy.uploadChunkSize;
|
|
}
|
|
core.debug(`Upload concurrency: ${result.uploadConcurrency}`);
|
|
core.debug(`Upload chunk size: ${result.uploadChunkSize}`);
|
|
return result;
|
|
};
|
|
var getDownloadOptions = function(copy) {
|
|
const result = {
|
|
useAzureSdk: true,
|
|
downloadConcurrency: 8,
|
|
timeoutInMs: 30000,
|
|
segmentTimeoutInMs: 600000,
|
|
lookupOnly: false
|
|
};
|
|
if (copy) {
|
|
if (typeof copy.useAzureSdk === "boolean")
|
|
result.useAzureSdk = copy.useAzureSdk;
|
|
if (typeof copy.downloadConcurrency === "number")
|
|
result.downloadConcurrency = copy.downloadConcurrency;
|
|
if (typeof copy.timeoutInMs === "number")
|
|
result.timeoutInMs = copy.timeoutInMs;
|
|
if (typeof copy.segmentTimeoutInMs === "number")
|
|
result.segmentTimeoutInMs = copy.segmentTimeoutInMs;
|
|
if (typeof copy.lookupOnly === "boolean")
|
|
result.lookupOnly = copy.lookupOnly;
|
|
}
|
|
const segmentDownloadTimeoutMins = process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"];
|
|
if (segmentDownloadTimeoutMins && !isNaN(Number(segmentDownloadTimeoutMins)) && isFinite(Number(segmentDownloadTimeoutMins)))
|
|
result.segmentTimeoutInMs = Number(segmentDownloadTimeoutMins) * 60 * 1000;
|
|
core.debug(`Use Azure SDK: ${result.useAzureSdk}`);
|
|
core.debug(`Download concurrency: ${result.downloadConcurrency}`);
|
|
core.debug(`Request timeout (ms): ${result.timeoutInMs}`);
|
|
core.debug(`Cache segment download timeout mins env var: ${process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"]}`);
|
|
core.debug(`Segment download timeout (ms): ${result.segmentTimeoutInMs}`);
|
|
core.debug(`Lookup only: ${result.lookupOnly}`);
|
|
return result;
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getDownloadOptions = exports.getUploadOptions = undefined;
|
|
var core = __importStar2(require_core());
|
|
exports.getUploadOptions = getUploadOptions;
|
|
exports.getDownloadOptions = getDownloadOptions;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/cacheHttpClient.js
|
|
var require_cacheHttpClient = __commonJS((exports) => {
|
|
var getCacheApiUrl = function(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;
|
|
};
|
|
var createAcceptHeader = function(type, apiVersion) {
|
|
return `${type};api-version=${apiVersion}`;
|
|
};
|
|
var getRequestOptions = function() {
|
|
const requestOptions = {
|
|
headers: {
|
|
Accept: createAcceptHeader("application/json", "6.0-preview.1")
|
|
}
|
|
};
|
|
return requestOptions;
|
|
};
|
|
var createHttpClient = function() {
|
|
const token = process.env["ACTIONS_RUNTIME_TOKEN"] || "";
|
|
const bearerCredentialHandler = new auth_1.BearerCredentialHandler(token);
|
|
return new http_client_1.HttpClient("actions/cache", [bearerCredentialHandler], getRequestOptions());
|
|
};
|
|
var getCacheVersion = function(paths, compressionMethod, enableCrossOsArchive = false) {
|
|
const components = paths;
|
|
if (compressionMethod)
|
|
components.push(compressionMethod);
|
|
if (process.platform === "win32" && !enableCrossOsArchive)
|
|
components.push("windows-only");
|
|
components.push(versionSalt);
|
|
return crypto7.createHash("sha256").update(components.join("|")).digest("hex");
|
|
};
|
|
var getCacheEntry = function(keys, paths, options) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const httpClient = createHttpClient();
|
|
const version3 = getCacheVersion(paths, options === null || options === undefined ? undefined : options.compressionMethod, options === null || options === undefined ? undefined : options.enableCrossOsArchive);
|
|
const resource = `cache?keys=${encodeURIComponent(keys.join(","))}&version=${version3}`;
|
|
const response = yield (0, requestUtils_1.retryTypedResponse)("getCacheEntry", () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.getJson(getCacheApiUrl(resource));
|
|
}));
|
|
if (response.statusCode === 204) {
|
|
if (core.isDebug())
|
|
yield printCachesListForDiagnostics(keys[0], httpClient, version3);
|
|
return null;
|
|
}
|
|
if (!(0, requestUtils_1.isSuccessStatusCode)(response.statusCode))
|
|
throw new Error(`Cache service responded with ${response.statusCode}`);
|
|
const cacheResult = response.result;
|
|
const cacheDownloadUrl = cacheResult === null || cacheResult === undefined ? undefined : cacheResult.archiveLocation;
|
|
if (!cacheDownloadUrl)
|
|
throw new Error("Cache not found.");
|
|
core.setSecret(cacheDownloadUrl);
|
|
core.debug(`Cache Result:`);
|
|
core.debug(JSON.stringify(cacheResult));
|
|
return cacheResult;
|
|
});
|
|
};
|
|
var printCachesListForDiagnostics = function(key, httpClient, version3) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const resource = `caches?key=${encodeURIComponent(key)}`;
|
|
const response = yield (0, requestUtils_1.retryTypedResponse)("listCache", () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.getJson(getCacheApiUrl(resource));
|
|
}));
|
|
if (response.statusCode === 200) {
|
|
const cacheListResult = response.result;
|
|
const totalCount = cacheListResult === null || cacheListResult === undefined ? undefined : cacheListResult.totalCount;
|
|
if (totalCount && totalCount > 0) {
|
|
core.debug(`No matching cache found for cache key '${key}', version '${version3} 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 === undefined ? undefined : cacheListResult.artifactCaches) || [])
|
|
core.debug(`Cache Key: ${cacheEntry === null || cacheEntry === undefined ? undefined : cacheEntry.cacheKey}, Cache Version: ${cacheEntry === null || cacheEntry === undefined ? undefined : cacheEntry.cacheVersion}, Cache Scope: ${cacheEntry === null || cacheEntry === undefined ? undefined : cacheEntry.scope}, Cache Created: ${cacheEntry === null || cacheEntry === undefined ? undefined : cacheEntry.creationTime}`);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
var downloadCache = function(archiveLocation, archivePath, options) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const archiveUrl = new url_1.URL(archiveLocation);
|
|
const downloadOptions = (0, options_1.getDownloadOptions)(options);
|
|
if (downloadOptions.useAzureSdk && archiveUrl.hostname.endsWith(".blob.core.windows.net"))
|
|
yield (0, downloadUtils_1.downloadCacheStorageSDK)(archiveLocation, archivePath, downloadOptions);
|
|
else
|
|
yield (0, downloadUtils_1.downloadCacheHttpClient)(archiveLocation, archivePath);
|
|
});
|
|
};
|
|
var reserveCache = function(key, paths, options) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const httpClient = createHttpClient();
|
|
const version3 = getCacheVersion(paths, options === null || options === undefined ? undefined : options.compressionMethod, options === null || options === undefined ? undefined : options.enableCrossOsArchive);
|
|
const reserveCacheRequest = {
|
|
key,
|
|
version: version3,
|
|
cacheSize: options === null || options === undefined ? undefined : options.cacheSize
|
|
};
|
|
const response = yield (0, requestUtils_1.retryTypedResponse)("reserveCache", () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.postJson(getCacheApiUrl("caches"), reserveCacheRequest);
|
|
}));
|
|
return response;
|
|
});
|
|
};
|
|
var getContentRange = function(start, end) {
|
|
return `bytes ${start}-${end}/*`;
|
|
};
|
|
var uploadChunk = function(httpClient, resourceUrl, openStream, start, end) {
|
|
return __awaiter2(this, undefined, undefined, 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 (0, requestUtils_1.retryHttpClientResponse)(`uploadChunk (start: ${start}, end: ${end})`, () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.sendStream("PATCH", resourceUrl, openStream(), additionalHeaders);
|
|
}));
|
|
if (!(0, requestUtils_1.isSuccessStatusCode)(uploadChunkResponse.message.statusCode))
|
|
throw new Error(`Cache service responded with ${uploadChunkResponse.message.statusCode} during upload chunk.`);
|
|
});
|
|
};
|
|
var uploadFile = function(httpClient, cacheId, archivePath, options) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const fileSize = utils.getArchiveFileSizeInBytes(archivePath);
|
|
const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
|
|
const fd = fs.openSync(archivePath, "r");
|
|
const uploadOptions = (0, 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(() => __awaiter2(this, undefined, undefined, 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;
|
|
});
|
|
};
|
|
var commitCache = function(httpClient, cacheId, filesize) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const commitCacheRequest = { size: filesize };
|
|
return yield (0, requestUtils_1.retryTypedResponse)("commitCache", () => __awaiter2(this, undefined, undefined, function* () {
|
|
return httpClient.postJson(getCacheApiUrl(`caches/${cacheId.toString()}`), commitCacheRequest);
|
|
}));
|
|
});
|
|
};
|
|
var saveCache = function(cacheId, archivePath, options) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const httpClient = createHttpClient();
|
|
core.debug("Upload cache");
|
|
yield uploadFile(httpClient, cacheId, archivePath, options);
|
|
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 (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode))
|
|
throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`);
|
|
core.info("Cache saved successfully");
|
|
});
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter2 = exports && exports.__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.saveCache = exports.reserveCache = exports.downloadCache = exports.getCacheEntry = exports.getCacheVersion = undefined;
|
|
var core = __importStar2(require_core());
|
|
var http_client_1 = require_lib();
|
|
var auth_1 = require_auth();
|
|
var crypto7 = __importStar2(__require("crypto"));
|
|
var fs = __importStar2(__require("fs"));
|
|
var url_1 = __require("url");
|
|
var utils = __importStar2(require_cacheUtils());
|
|
var downloadUtils_1 = require_downloadUtils();
|
|
var options_1 = require_options();
|
|
var requestUtils_1 = require_requestUtils();
|
|
var versionSalt = "1.0";
|
|
exports.getCacheVersion = getCacheVersion;
|
|
exports.getCacheEntry = getCacheEntry;
|
|
exports.downloadCache = downloadCache;
|
|
exports.reserveCache = reserveCache;
|
|
exports.saveCache = saveCache;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/internal/tar.js
|
|
var require_tar = __commonJS((exports) => {
|
|
var getTarPath = function() {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
switch (process.platform) {
|
|
case "win32": {
|
|
const gnuTar = yield utils.getGnuTarPathOnWindows();
|
|
const systemTar = constants_1.SystemTarPathOnWindows;
|
|
if (gnuTar)
|
|
return { path: gnuTar, type: constants_1.ArchiveToolType.GNU };
|
|
else if ((0, fs_1.existsSync)(systemTar))
|
|
return { path: systemTar, type: constants_1.ArchiveToolType.BSD };
|
|
break;
|
|
}
|
|
case "darwin": {
|
|
const gnuTar = yield io.which("gtar", false);
|
|
if (gnuTar)
|
|
return { path: gnuTar, type: constants_1.ArchiveToolType.GNU };
|
|
else
|
|
return {
|
|
path: yield io.which("tar", true),
|
|
type: constants_1.ArchiveToolType.BSD
|
|
};
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return {
|
|
path: yield io.which("tar", true),
|
|
type: constants_1.ArchiveToolType.GNU
|
|
};
|
|
});
|
|
};
|
|
var getTarArgs = function(tarPath, compressionMethod, type, archivePath = "") {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const args = [`"${tarPath.path}"`];
|
|
const cacheFileName = utils.getCacheFileName(compressionMethod);
|
|
const tarFile = "cache.tar";
|
|
const workingDirectory = getWorkingDirectory();
|
|
const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
|
|
switch (type) {
|
|
case "create":
|
|
args.push("--posix", "-cf", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path.sep}`, "g"), "/"), "--exclude", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path.sep}`, "g"), "/"), "--files-from", constants_1.ManifestFilename);
|
|
break;
|
|
case "extract":
|
|
args.push("-xf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path.sep}`, "g"), "/"));
|
|
break;
|
|
case "list":
|
|
args.push("-tf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path.sep}`, "g"), "/"), "-P");
|
|
break;
|
|
}
|
|
if (tarPath.type === constants_1.ArchiveToolType.GNU)
|
|
switch (process.platform) {
|
|
case "win32":
|
|
args.push("--force-local");
|
|
break;
|
|
case "darwin":
|
|
args.push("--delay-directory-restore");
|
|
break;
|
|
}
|
|
return args;
|
|
});
|
|
};
|
|
var getCommands = function(compressionMethod, type, archivePath = "") {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
let args;
|
|
const tarPath = yield getTarPath();
|
|
const tarArgs = yield getTarArgs(tarPath, compressionMethod, type, archivePath);
|
|
const compressionArgs = type !== "create" ? yield getDecompressionProgram(tarPath, compressionMethod, archivePath) : yield getCompressionProgram(tarPath, compressionMethod);
|
|
const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
|
|
if (BSD_TAR_ZSTD && type !== "create")
|
|
args = [[...compressionArgs].join(" "), [...tarArgs].join(" ")];
|
|
else
|
|
args = [[...tarArgs].join(" "), [...compressionArgs].join(" ")];
|
|
if (BSD_TAR_ZSTD)
|
|
return args;
|
|
return [args.join(" ")];
|
|
});
|
|
};
|
|
var getWorkingDirectory = function() {
|
|
var _a;
|
|
return (_a = process.env["GITHUB_WORKSPACE"]) !== null && _a !== undefined ? _a : process.cwd();
|
|
};
|
|
var getDecompressionProgram = function(tarPath, compressionMethod, archivePath) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
|
|
switch (compressionMethod) {
|
|
case constants_1.CompressionMethod.Zstd:
|
|
return BSD_TAR_ZSTD ? [
|
|
"zstd -d --long=30 --force -o",
|
|
constants_1.TarFilename,
|
|
archivePath.replace(new RegExp(`\\${path.sep}`, "g"), "/")
|
|
] : [
|
|
"--use-compress-program",
|
|
IS_WINDOWS ? '"zstd -d --long=30"' : "unzstd --long=30"
|
|
];
|
|
case constants_1.CompressionMethod.ZstdWithoutLong:
|
|
return BSD_TAR_ZSTD ? [
|
|
"zstd -d --force -o",
|
|
constants_1.TarFilename,
|
|
archivePath.replace(new RegExp(`\\${path.sep}`, "g"), "/")
|
|
] : ["--use-compress-program", IS_WINDOWS ? '"zstd -d"' : "unzstd"];
|
|
default:
|
|
return ["-z"];
|
|
}
|
|
});
|
|
};
|
|
var getCompressionProgram = function(tarPath, compressionMethod) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const cacheFileName = utils.getCacheFileName(compressionMethod);
|
|
const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
|
|
switch (compressionMethod) {
|
|
case constants_1.CompressionMethod.Zstd:
|
|
return BSD_TAR_ZSTD ? [
|
|
"zstd -T0 --long=30 --force -o",
|
|
cacheFileName.replace(new RegExp(`\\${path.sep}`, "g"), "/"),
|
|
constants_1.TarFilename
|
|
] : [
|
|
"--use-compress-program",
|
|
IS_WINDOWS ? '"zstd -T0 --long=30"' : "zstdmt --long=30"
|
|
];
|
|
case constants_1.CompressionMethod.ZstdWithoutLong:
|
|
return BSD_TAR_ZSTD ? [
|
|
"zstd -T0 --force -o",
|
|
cacheFileName.replace(new RegExp(`\\${path.sep}`, "g"), "/"),
|
|
constants_1.TarFilename
|
|
] : ["--use-compress-program", IS_WINDOWS ? '"zstd -T0"' : "zstdmt"];
|
|
default:
|
|
return ["-z"];
|
|
}
|
|
});
|
|
};
|
|
var execCommands = function(commands, cwd) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
for (const command of commands)
|
|
try {
|
|
yield (0, exec_1.exec)(command, undefined, {
|
|
cwd,
|
|
env: Object.assign(Object.assign({}, process.env), { MSYS: "winsymlinks:nativestrict" })
|
|
});
|
|
} catch (error) {
|
|
throw new Error(`${command.split(" ")[0]} failed with error: ${error === null || error === undefined ? undefined : error.message}`);
|
|
}
|
|
});
|
|
};
|
|
var listTar = function(archivePath, compressionMethod) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const commands = yield getCommands(compressionMethod, "list", archivePath);
|
|
yield execCommands(commands);
|
|
});
|
|
};
|
|
var extractTar = function(archivePath, compressionMethod) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
const workingDirectory = getWorkingDirectory();
|
|
yield io.mkdirP(workingDirectory);
|
|
const commands = yield getCommands(compressionMethod, "extract", archivePath);
|
|
yield execCommands(commands);
|
|
});
|
|
};
|
|
var createTar = function(archiveFolder, sourceDirectories, compressionMethod) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
(0, fs_1.writeFileSync)(path.join(archiveFolder, constants_1.ManifestFilename), sourceDirectories.join("\n"));
|
|
const commands = yield getCommands(compressionMethod, "create");
|
|
yield execCommands(commands, archiveFolder);
|
|
});
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter2 = exports && exports.__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.createTar = exports.extractTar = exports.listTar = undefined;
|
|
var exec_1 = require_exec();
|
|
var io = __importStar2(require_io());
|
|
var fs_1 = __require("fs");
|
|
var path = __importStar2(__require("path"));
|
|
var utils = __importStar2(require_cacheUtils());
|
|
var constants_1 = require_constants();
|
|
var IS_WINDOWS = process.platform === "win32";
|
|
exports.listTar = listTar;
|
|
exports.extractTar = extractTar;
|
|
exports.createTar = createTar;
|
|
});
|
|
|
|
// node_modules/@actions/cache/lib/cache.js
|
|
var require_cache = __commonJS((exports) => {
|
|
var checkPaths = function(paths) {
|
|
if (!paths || paths.length === 0)
|
|
throw new ValidationError(`Path Validation Error: At least one directory or file path is required`);
|
|
};
|
|
var checkKey = function(key) {
|
|
if (key.length > 512)
|
|
throw new ValidationError(`Key Validation Error: ${key} cannot be larger than 512 characters.`);
|
|
const regex3 = /^[^,]*$/;
|
|
if (!regex3.test(key))
|
|
throw new ValidationError(`Key Validation Error: ${key} cannot contain commas.`);
|
|
};
|
|
var isFeatureAvailable = function() {
|
|
return !!process.env["ACTIONS_CACHE_URL"];
|
|
};
|
|
var restoreCache = function(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
checkPaths(paths);
|
|
restoreKeys = restoreKeys || [];
|
|
const keys = [primaryKey, ...restoreKeys];
|
|
core.debug("Resolved Keys:");
|
|
core.debug(JSON.stringify(keys));
|
|
if (keys.length > 10)
|
|
throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`);
|
|
for (const key of keys)
|
|
checkKey(key);
|
|
const compressionMethod = yield utils.getCompressionMethod();
|
|
let archivePath = "";
|
|
try {
|
|
const cacheEntry = yield cacheHttpClient.getCacheEntry(keys, paths, {
|
|
compressionMethod,
|
|
enableCrossOsArchive
|
|
});
|
|
if (!(cacheEntry === null || cacheEntry === undefined ? undefined : cacheEntry.archiveLocation))
|
|
return;
|
|
if (options === null || options === undefined ? undefined : options.lookupOnly) {
|
|
core.info("Lookup only - skipping download");
|
|
return cacheEntry.cacheKey;
|
|
}
|
|
archivePath = path.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
|
|
core.debug(`Archive Path: ${archivePath}`);
|
|
yield cacheHttpClient.downloadCache(cacheEntry.archiveLocation, archivePath, options);
|
|
if (core.isDebug())
|
|
yield (0, tar_1.listTar)(archivePath, compressionMethod);
|
|
const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
|
|
core.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
|
|
yield (0, tar_1.extractTar)(archivePath, compressionMethod);
|
|
core.info("Cache restored successfully");
|
|
return cacheEntry.cacheKey;
|
|
} catch (error) {
|
|
const typedError = error;
|
|
if (typedError.name === ValidationError.name)
|
|
throw error;
|
|
else
|
|
core.warning(`Failed to restore: ${error.message}`);
|
|
} finally {
|
|
try {
|
|
yield utils.unlinkFile(archivePath);
|
|
} catch (error) {
|
|
core.debug(`Failed to delete archive: ${error}`);
|
|
}
|
|
}
|
|
return;
|
|
});
|
|
};
|
|
var saveCache = function(paths, key, options, enableCrossOsArchive = false) {
|
|
var _a, _b, _c, _d, _e;
|
|
return __awaiter2(this, undefined, undefined, function* () {
|
|
checkPaths(paths);
|
|
checkKey(key);
|
|
const compressionMethod = yield utils.getCompressionMethod();
|
|
let cacheId = -1;
|
|
const cachePaths = yield utils.resolvePaths(paths);
|
|
core.debug("Cache Paths:");
|
|
core.debug(`${JSON.stringify(cachePaths)}`);
|
|
if (cachePaths.length === 0)
|
|
throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
|
|
const archiveFolder = yield utils.createTempDirectory();
|
|
const archivePath = path.join(archiveFolder, utils.getCacheFileName(compressionMethod));
|
|
core.debug(`Archive Path: ${archivePath}`);
|
|
try {
|
|
yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod);
|
|
if (core.isDebug())
|
|
yield (0, tar_1.listTar)(archivePath, compressionMethod);
|
|
const fileSizeLimit = 10 * 1024 * 1024 * 1024;
|
|
const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
|
|
core.debug(`File Size: ${archiveFileSize}`);
|
|
if (archiveFileSize > fileSizeLimit && !utils.isGhes())
|
|
throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`);
|
|
core.debug("Reserving Cache");
|
|
const reserveCacheResponse = yield cacheHttpClient.reserveCache(key, paths, {
|
|
compressionMethod,
|
|
enableCrossOsArchive,
|
|
cacheSize: archiveFileSize
|
|
});
|
|
if ((_a = reserveCacheResponse === null || reserveCacheResponse === undefined ? undefined : reserveCacheResponse.result) === null || _a === undefined ? undefined : _a.cacheId)
|
|
cacheId = (_b = reserveCacheResponse === null || reserveCacheResponse === undefined ? undefined : reserveCacheResponse.result) === null || _b === undefined ? undefined : _b.cacheId;
|
|
else if ((reserveCacheResponse === null || reserveCacheResponse === undefined ? undefined : reserveCacheResponse.statusCode) === 400)
|
|
throw new Error((_d = (_c = reserveCacheResponse === null || reserveCacheResponse === undefined ? undefined : reserveCacheResponse.error) === null || _c === undefined ? undefined : _c.message) !== null && _d !== undefined ? _d : `Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`);
|
|
else
|
|
throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_e = reserveCacheResponse === null || reserveCacheResponse === undefined ? undefined : reserveCacheResponse.error) === null || _e === undefined ? undefined : _e.message}`);
|
|
core.debug(`Saving Cache (ID: ${cacheId})`);
|
|
yield cacheHttpClient.saveCache(cacheId, archivePath, options);
|
|
} catch (error) {
|
|
const typedError = error;
|
|
if (typedError.name === ValidationError.name)
|
|
throw error;
|
|
else if (typedError.name === ReserveCacheError.name)
|
|
core.info(`Failed to save: ${typedError.message}`);
|
|
else
|
|
core.warning(`Failed to save: ${typedError.message}`);
|
|
} finally {
|
|
try {
|
|
yield utils.unlinkFile(archivePath);
|
|
} catch (error) {
|
|
core.debug(`Failed to delete archive: ${error}`);
|
|
}
|
|
}
|
|
return cacheId;
|
|
});
|
|
};
|
|
var __createBinding2 = exports && exports.__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 __setModuleDefault2 = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar2 = exports && exports.__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))
|
|
__createBinding2(result, mod, k);
|
|
}
|
|
__setModuleDefault2(result, mod);
|
|
return result;
|
|
};
|
|
var __awaiter2 = exports && exports.__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.saveCache = exports.restoreCache = exports.isFeatureAvailable = exports.ReserveCacheError = exports.ValidationError = undefined;
|
|
var core = __importStar2(require_core());
|
|
var path = __importStar2(__require("path"));
|
|
var utils = __importStar2(require_cacheUtils());
|
|
var cacheHttpClient = __importStar2(require_cacheHttpClient());
|
|
var tar_1 = require_tar();
|
|
|
|
class ValidationError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "ValidationError";
|
|
Object.setPrototypeOf(this, ValidationError.prototype);
|
|
}
|
|
}
|
|
exports.ValidationError = ValidationError;
|
|
|
|
class ReserveCacheError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = "ReserveCacheError";
|
|
Object.setPrototypeOf(this, ReserveCacheError.prototype);
|
|
}
|
|
}
|
|
exports.ReserveCacheError = ReserveCacheError;
|
|
exports.isFeatureAvailable = isFeatureAvailable;
|
|
exports.restoreCache = restoreCache;
|
|
exports.saveCache = saveCache;
|
|
});
|
|
// src/action.ts
|
|
var action2 = __toESM(require_core());
|
|
import {tmpdir} from "node:os";
|
|
|
|
// src/setup.ts
|
|
var action = __toESM(require_core());
|
|
var tool_cache = __toESM(require_tool_cache());
|
|
var cache = __toESM(require_cache());
|
|
var cache2 = __toESM(require_cache());
|
|
var io = __toESM(require_io());
|
|
var exec = __toESM(require_exec());
|
|
import {homedir} from "node:os";
|
|
import {join} from "node:path";
|
|
import {readdir, symlink} from "node:fs/promises";
|
|
var getCacheKey = function(options) {
|
|
const { customUrl } = options;
|
|
if (customUrl)
|
|
return customUrl;
|
|
const { os, arch, baseline, profile, version: version3 } = options;
|
|
let name = `bun-${os}-${arch}`;
|
|
if (baseline)
|
|
name += "-baseline";
|
|
if (profile)
|
|
name += "-profile";
|
|
return `${name}@${version3}`;
|
|
};
|
|
var getDownloadUrl = function(options) {
|
|
const { customUrl } = options;
|
|
if (customUrl)
|
|
return new URL(customUrl);
|
|
const { version: version3, os, arch, baseline, profile } = options;
|
|
const url = new URL(`${encodeURIComponent(version3)}/${os}/${arch}/bun.zip`, "https://bun.sh/download/");
|
|
if (baseline)
|
|
url.searchParams.set("baseline", "true");
|
|
if (profile)
|
|
url.searchParams.set("profile", "true");
|
|
return url;
|
|
};
|
|
async function extractFileFromZip(path, filename) {
|
|
for (const entry of await readdir(path, { withFileTypes: true })) {
|
|
const { name } = entry;
|
|
const entryPath = join(path, name);
|
|
if (entry.isFile()) {
|
|
if (name === filename)
|
|
return entryPath;
|
|
if (name.includes(filename) && name.endsWith(".zip")) {
|
|
const extractedPath = await tool_cache.extractZip(entryPath);
|
|
return extractFileFromZip(extractedPath, filename);
|
|
}
|
|
}
|
|
if (name.includes(filename) && entry.isDirectory())
|
|
return extractFileFromZip(entryPath, filename);
|
|
}
|
|
throw new Error(`Failed to extract '${filename}' from '${path}'.`);
|
|
}
|
|
async function getVersion(path) {
|
|
const { exitCode, stdout } = await exec.getExecOutput(path, ["--version"], {
|
|
ignoreReturnCode: true
|
|
});
|
|
return exitCode === 0 ? stdout.trim() : undefined;
|
|
}
|
|
async function setup_default(options) {
|
|
const url = getDownloadUrl(options);
|
|
const cacheKey = getCacheKey(options);
|
|
const cacheEnabled = cache.isFeatureAvailable();
|
|
const path = join(homedir(), ".bun", "bin");
|
|
action.addPath(path);
|
|
const bunPath = join(path, "bun");
|
|
const bunxPath = join(path, "bunx");
|
|
let version3;
|
|
let cacheHit = false;
|
|
if (!options.checkLatest && cacheEnabled) {
|
|
const cacheRestored = await cache2.restoreCache([bunPath], cacheKey);
|
|
if (cacheRestored) {
|
|
version3 = await getVersion(bunPath);
|
|
if (version3) {
|
|
cacheHit = true;
|
|
action.info("Found a cached version of Bun.");
|
|
} else
|
|
action.warning("Found a cached version of Bun, but it appears to be corrupted? Attempting to download a new version.");
|
|
}
|
|
}
|
|
if (!cacheHit) {
|
|
action.info(`Downloading a new version of Bun: ${url}`);
|
|
const zipPath = await tool_cache.downloadTool(url.toString());
|
|
const extractedPath = await tool_cache.extractZip(zipPath);
|
|
const exePath = await extractFileFromZip(extractedPath, "bun");
|
|
await io.mv(exePath, bunPath);
|
|
version3 = await getVersion(bunPath);
|
|
}
|
|
if (!version3)
|
|
throw new Error("Downloaded a new version of Bun, but failed to check its version? Try again in debug mode.");
|
|
try {
|
|
await symlink(bunPath, bunxPath);
|
|
} catch (error) {
|
|
if (error.code !== "EEXIST")
|
|
throw error;
|
|
}
|
|
if (cacheEnabled)
|
|
try {
|
|
await cache2.saveCache([bunPath], cacheKey);
|
|
} catch (error) {
|
|
action.warning("Failed to save Bun to cache.");
|
|
}
|
|
return {
|
|
version: version3,
|
|
cacheHit
|
|
};
|
|
}
|
|
|
|
// src/action.ts
|
|
var parseBoolean = function(value) {
|
|
return /^true$/i.test(value);
|
|
};
|
|
if (!process.env.RUNNER_TEMP)
|
|
process.env.RUNNER_TEMP = tmpdir();
|
|
setup_default({
|
|
customUrl: action2.getInput("bun-download-url") || undefined,
|
|
checkLatest: parseBoolean(action2.getInput("check-latest")),
|
|
version: action2.getInput("bun-version") || "latest",
|
|
os: process.platform,
|
|
arch: process.arch,
|
|
baseline: parseBoolean(action2.getInput("baseline")),
|
|
profile: parseBoolean(action2.getInput("profile"))
|
|
}).then(({ version: version3, cacheHit }) => {
|
|
action2.setOutput("bun-version", version3);
|
|
action2.setOutput("cache-hit", cacheHit);
|
|
}).catch((error) => {
|
|
action2.setFailed(error);
|
|
});
|